def read_dataset(fp: BinaryIO, is_implicit_VR: bool, is_little_endian: bool, bytelength: Optional[int] = None, stop_when: Optional[Callable[[BaseTag, Optional[str], int], bool]] = None, defer_size: Optional[Union[str, int, float]] = None, parent_encoding: Union[ str, MutableSequence[str]] = default_encoding, specific_tags: Optional[List[BaseTag]] = None, at_top_level: bool = True) -> Dataset: """Return a :class:`~pydicom.dataset.Dataset` instance containing the next dataset in the file. Parameters ---------- fp : file-like An opened file-like object. is_implicit_VR : bool ``True`` if file transfer syntax is implicit VR. is_little_endian : bool ``True`` if file has little endian transfer syntax. bytelength : int, None, optional ``None`` to read until end of file or ItemDeliterTag, else a fixed number of bytes to read stop_when : None, optional Optional call_back function which can terminate reading. See help for :func:`data_element_generator` for details defer_size : int, str or float, optional Size to avoid loading large elements in memory. See :func:`dcmread` for more parameter info. parent_encoding : str or List[str] Optional encoding to use as a default in case (0008,0005) *Specific Character Set* isn't specified. specific_tags : list of BaseTag, optional See :func:`dcmread` for parameter info. at_top_level: bool If dataset is top level (not within a sequence). Used to turn off explicit VR heuristic within sequences Returns ------- dataset.Dataset A Dataset instance. See Also -------- :class:`~pydicom.dataset.Dataset` A collection (dictionary) of DICOM :class:`~pydicom.dataelem.DataElement` instances. """ raw_data_elements: Dict[BaseTag, Union[RawDataElement, DataElement]] = {} fp_start = fp.tell() is_implicit_VR = _is_implicit_vr(fp, is_implicit_VR, is_little_endian, stop_when, is_sequence=not at_top_level) fp.seek(fp_start) de_gen = data_element_generator( fp, is_implicit_VR, is_little_endian, stop_when, defer_size, parent_encoding, specific_tags, ) try: while (bytelength is None) or (fp.tell() - fp_start < bytelength): raw_data_element = next(de_gen) # Read data elements. Stop on some errors, but return what was read tag = raw_data_element.tag # Check for ItemDelimiterTag --dataset is an item in a sequence if tag == BaseTag(0xFFFEE00D): break raw_data_elements[tag] = raw_data_element except StopIteration: pass except EOFError as details: if config.settings.reading_validation_mode == config.RAISE: raise msg = str(details) + " in file " + getattr(fp, "name", "<no filename>") warnings.warn(msg, UserWarning) except NotImplementedError as details: logger.error(details) ds = Dataset(raw_data_elements) encoding: Union[str, MutableSequence[str]] if 0x00080005 in raw_data_elements: elem = cast(RawDataElement, raw_data_elements[BaseTag(0x00080005)]) char_set = cast(Optional[Union[str, MutableSequence[str]]], DataElement_from_raw(elem).value) encoding = convert_encodings(char_set) # -> List[str] else: encoding = parent_encoding # -> Union[str, MutableSequence[str]] ds.set_original_encoding(is_implicit_VR, is_little_endian, encoding) return ds
def test_mixed_long_int(self): assert Tag([0x1000, long(0x2000)]) == BaseTag(0x10002000) assert Tag([long(0x1000), 0x2000]) == BaseTag(0x10002000) assert Tag([long(0x1000), long(0x2000)]) == BaseTag(0x10002000)
def test_tuple_tag(self): """Test quick tag construction with TupleTag.""" assert TupleTag((0xFFFF, 0xFFee)) == BaseTag(0xFFFFFFEE)
def test_hash(self): """Test hash of BaseTag class.""" assert hash(BaseTag(0x00010001)) == hash(BaseTag(0x00010001)) assert hash(BaseTag(0x00010001)) != hash(BaseTag(0x00010002)) assert hash(BaseTag(0x00020001)) != hash(BaseTag(0x00010002))
def test_group(self): """Test BaseTag.group returns correct values.""" assert BaseTag(0x00000001).group == 0x0000 assert BaseTag(0x00020001).group == 0x0002 assert BaseTag(0xFFFF0001).group == 0xFFFF
def test_ne_same_class(self): """Test __ne__ of two classes with same type.""" assert not BaseTag(0x00000000) != BaseTag(0x00000000) assert BaseTag(0x00000001) != BaseTag(0x00000000)
def test_le_diff_class(self): """Test __le__ of two classes with different type.""" assert BaseTag(0x00000000) <= 1 assert BaseTag(0x00000001) <= 1 assert not BaseTag(0x00000001) <= 0
def read_dataset(fp, is_implicit_VR, is_little_endian, bytelength=None, stop_when=None, defer_size=None, parent_encoding=default_encoding, specific_tags=None): """Return a Dataset instance containing the next dataset in the file. Parameters ---------- fp : an opened file object is_implicit_VR : boolean True if file transfer syntax is implicit VR. is_little_endian : boolean True if file has little endian transfer syntax. bytelength : int, None, optional None to read until end of file or ItemDeliterTag, else a fixed number of bytes to read stop_when : None, optional optional call_back function which can terminate reading. See help for data_element_generator for details defer_size : int, None, optional Size to avoid loading large elements in memory. See ``dcmread`` for more parameter info. parent_encoding : optional encoding to use as a default in case a Specific Character Set (0008,0005) isn't specified specific_tags : list or None See ``dcmread`` for parameter info. Returns ------- a Dataset instance See Also -------- pydicom.dataset.Dataset A collection (dictionary) of Dicom `DataElement` instances. """ raw_data_elements = dict() fpStart = fp.tell() de_gen = data_element_generator(fp, is_implicit_VR, is_little_endian, stop_when, defer_size, parent_encoding, specific_tags) try: while (bytelength is None) or (fp.tell() - fpStart < bytelength): raw_data_element = next(de_gen) # Read data elements. Stop on some errors, but return what was read tag = raw_data_element.tag # Check for ItemDelimiterTag --dataset is an item in a sequence if tag == BaseTag(0xFFFEE00D): break raw_data_elements[tag] = raw_data_element except StopIteration: pass except EOFError as details: # XXX is this error visible enough to user code with just logging? logger.error( str(details) + " in file " + getattr(fp, "name", "<no filename>")) except NotImplementedError as details: logger.error(details) ds = Dataset(raw_data_elements) if 0x00080005 in raw_data_elements: char_set = DataElement_from_raw(raw_data_elements[0x00080005]) encoding = convert_encodings(char_set) else: encoding = parent_encoding ds.set_original_encoding(is_implicit_VR, is_little_endian, encoding) return ds
def data_element_generator(fp, is_implicit_VR, is_little_endian, stop_when=None, defer_size=None, encoding=default_encoding, specific_tags=None): """Create a generator to efficiently return the raw data elements. .. note:: This function is used internally - usually there is no need to call it from user code. To read data from a DICOM file, :func:`dcmread` shall be used instead. Parameters ---------- fp : file-like The file-like to read from. is_implicit_VR : bool ``True`` if the data is encoded as implicit VR, ``False`` otherwise. is_little_endian : bool ``True`` if the data is encoded as little endian, ``False`` otherwise. stop_when : None, callable, optional If ``None`` (default), then the whole file is read. A callable which takes tag, VR, length, and returns ``True`` or ``False``. If it returns ``True``, ``read_data_element`` will just return. defer_size : int, str, None, optional See :func:`dcmread` for parameter info. encoding : Encoding scheme specific_tags : list or None See :func:`dcmread` for parameter info. Returns ------- VR : str or None ``None`` if implicit VR, otherwise the VR read from the file. length : int The length of the DICOM data element (could be DICOM "undefined length" ``0xFFFFFFFFL``) value_bytes : bytes or str The raw bytes from the DICOM file (not parsed into Python types) is_little_endian : bool ``True`` if transfer syntax is little endian; else ``False``. """ # Summary of DICOM standard PS3.5-2008 chapter 7: # If Implicit VR, data element is: # tag, 4-byte length, value. # The 4-byte length can be FFFFFFFF (undefined length)* # # If Explicit VR: # if OB, OW, OF, SQ, UN, or UT: # tag, VR, 2-bytes reserved (both zero), 4-byte length, value # For all but UT, the length can be FFFFFFFF (undefined length)* # else: (any other VR) # tag, VR, (2 byte length), value # * for undefined length, a Sequence Delimitation Item marks the end # of the Value Field. # Note, except for the special_VRs, both impl and expl VR use 8 bytes; # the special VRs follow the 8 bytes with a 4-byte length # With a generator, state is stored, so we can break down # into the individual cases, and not have to check them again for each # data element if is_little_endian: endian_chr = "<" else: endian_chr = ">" if is_implicit_VR: element_struct = Struct(endian_chr + "HHL") else: # Explicit VR # tag, VR, 2-byte length (or 0 if special VRs) element_struct = Struct(endian_chr + "HH2sH") extra_length_struct = Struct(endian_chr + "L") # for special VRs extra_length_unpack = extra_length_struct.unpack # for lookup speed # Make local variables so have faster lookup fp_read = fp.read fp_tell = fp.tell logger_debug = logger.debug debugging = config.debugging element_struct_unpack = element_struct.unpack defer_size = size_in_bytes(defer_size) tag_set = set() if specific_tags is not None: for tag in specific_tags: if isinstance(tag, str): tag = Tag(tag_for_keyword(tag)) if isinstance(tag, BaseTag): tag_set.add(tag) tag_set.add(Tag(0x08, 0x05)) has_tag_set = len(tag_set) > 0 while True: # Read tag, VR, length, get ready to read value bytes_read = fp_read(8) if len(bytes_read) < 8: return # at end of file if debugging: debug_msg = "{0:08x}: {1}".format(fp.tell() - 8, bytes2hex(bytes_read)) if is_implicit_VR: # must reset VR each time; could have set last iteration (e.g. SQ) VR = None group, elem, length = element_struct_unpack(bytes_read) else: # explicit VR group, elem, VR, length = element_struct_unpack(bytes_read) VR = VR.decode(default_encoding) if VR in extra_length_VRs: bytes_read = fp_read(4) length = extra_length_unpack(bytes_read)[0] if debugging: debug_msg += " " + bytes2hex(bytes_read) if debugging: debug_msg = "%-47s (%04x, %04x)" % (debug_msg, group, elem) if not is_implicit_VR: debug_msg += " %s " % VR if length != 0xFFFFFFFF: debug_msg += "Length: %d" % length else: debug_msg += "Length: Undefined length (FFFFFFFF)" logger_debug(debug_msg) # Positioned to read the value, but may not want to -- check stop_when value_tell = fp_tell() tag = TupleTag((group, elem)) if stop_when is not None: # XXX VR may be None here!! Should stop_when just take tag? if stop_when(tag, VR, length): if debugging: logger_debug("Reading ended by stop_when callback. " "Rewinding to start of data element.") rewind_length = 8 if not is_implicit_VR and VR in extra_length_VRs: rewind_length += 4 fp.seek(value_tell - rewind_length) return # Reading the value # First case (most common): reading a value with a defined length if length != 0xFFFFFFFF: # don't defer loading of Specific Character Set value as it is # needed immediately to get the character encoding for other tags if has_tag_set and tag not in tag_set: # skip the tag if not in specific tags fp.seek(fp_tell() + length) continue if (defer_size is not None and length > defer_size and tag != BaseTag(0x00080005)): # Flag as deferred by setting value to None, and skip bytes value = None logger_debug("Defer size exceeded. " "Skipping forward to next data element.") fp.seek(fp_tell() + length) else: value = (fp_read(length) if length > 0 else empty_value_for_VR(VR, raw=True)) if debugging: dotdot = "..." if length > 12 else " " displayed_value = value[:12] if value else b'' logger_debug("%08x: %-34s %s %r %s" % (value_tell, bytes2hex(displayed_value), dotdot, displayed_value, dotdot)) # If the tag is (0008,0005) Specific Character Set, then store it if tag == BaseTag(0x00080005): from pydicom.values import convert_string encoding = convert_string(value or b'', is_little_endian) # Store the encoding value in the generator # for use with future elements (SQs) encoding = convert_encodings(encoding) yield RawDataElement(tag, VR, length, value, value_tell, is_implicit_VR, is_little_endian) # Second case: undefined length - must seek to delimiter, # unless is SQ type, in which case is easier to parse it, because # undefined length SQs and items of undefined lengths can be nested # and it would be error-prone to read to the correct outer delimiter else: # Try to look up type to see if is a SQ # if private tag, won't be able to look it up in dictionary, # in which case just ignore it and read the bytes unless it is # identified as a Sequence if VR is None: try: VR = dictionary_VR(tag) except KeyError: # Look ahead to see if it consists of items # and is thus a SQ next_tag = TupleTag(unpack(endian_chr + "HH", fp_read(4))) # Rewind the file fp.seek(fp_tell() - 4) if next_tag == ItemTag: VR = 'SQ' if VR == 'SQ': if debugging: msg = "{0:08x}: Reading/parsing undefined length sequence" logger_debug(msg.format(fp_tell())) seq = read_sequence(fp, is_implicit_VR, is_little_endian, length, encoding) if has_tag_set and tag not in tag_set: continue yield DataElement(tag, VR, seq, value_tell, is_undefined_length=True) else: delimiter = SequenceDelimiterTag if debugging: logger_debug("Reading undefined length data element") value = read_undefined_length_value(fp, is_little_endian, delimiter, defer_size) # tags with undefined length are skipped after read if has_tag_set and tag not in tag_set: continue yield RawDataElement(tag, VR, length, value, value_tell, is_implicit_VR, is_little_endian)
def test_ne_tuple(self): """Test __ne__ of tuple with BaseTag.""" # Make sure to test BaseTag.__ne__() not tuple.__ne__() assert not BaseTag(0x00010002) != (0x0001, 0x0002) assert BaseTag(0x00010001) != (0x0001, 0x0002)
def test_group(self): """Test BaseTag.group returns correct values.""" assert 0x0000 == BaseTag(0x00000001).group assert 0x0002 == BaseTag(0x00020001).group assert 0xFFFF == BaseTag(0xFFFF0001).group
def test_ne_subclass(self): """Test __ne__ of two classes with one as a subclass.""" class BaseTagPlus(BaseTag): pass assert not BaseTagPlus(0x00000000) != BaseTag(0x00000000) assert BaseTagPlus(0x00000001) != BaseTag(0x00000000)
def test_ne_diff_class(self): """Test __ne__ of two classes with different type.""" # Make sure to test BaseTag.__ne__() not int.__ne__() assert not BaseTag(0x00000000) != 0 assert BaseTag(0x00000001) != 0
def data_element_generator( fp: BinaryIO, is_implicit_VR: bool, is_little_endian: bool, stop_when: Optional[Callable[[BaseTag, Optional[str], int], bool]] = None, defer_size: Optional[Union[int, str, float]] = None, encoding: Union[str, MutableSequence[str]] = default_encoding, specific_tags: Optional[List[BaseTag]] = None ) -> Iterator[Union[RawDataElement, DataElement]]: """Create a generator to efficiently return the raw data elements. .. note:: This function is used internally - usually there is no need to call it from user code. To read data from a DICOM file, :func:`dcmread` shall be used instead. Parameters ---------- fp : file-like The file-like to read from. is_implicit_VR : bool ``True`` if the data is encoded as implicit VR, ``False`` otherwise. is_little_endian : bool ``True`` if the data is encoded as little endian, ``False`` otherwise. stop_when : None, callable, optional If ``None`` (default), then the whole file is read. A callable which takes tag, VR, length, and returns ``True`` or ``False``. If it returns ``True``, ``read_data_element`` will just return. defer_size : int, str or float, optional See :func:`dcmread` for parameter info. encoding : Union[str, MutableSequence[str]] Encoding scheme specific_tags : list or None See :func:`dcmread` for parameter info. Yields ------- RawDataElement or DataElement Yields DataElement for undefined length UN or SQ, RawDataElement otherwise. """ # Summary of DICOM standard PS3.5-2008 chapter 7: # If Implicit VR, data element is: # tag, 4-byte length, value. # The 4-byte length can be FFFFFFFF (undefined length)* # # If Explicit VR: # if OB, OW, OF, SQ, UN, or UT: # tag, VR, 2-bytes reserved (both zero), 4-byte length, value # For all but UT, the length can be FFFFFFFF (undefined length)* # else: (any other VR) # tag, VR, (2 byte length), value # * for undefined length, a Sequence Delimitation Item marks the end # of the Value Field. # Note, except for the special_VRs, both impl and expl VR use 8 bytes; # the special VRs follow the 8 bytes with a 4-byte length # With a generator, state is stored, so we can break down # into the individual cases, and not have to check them again for each # data element from pydicom.values import convert_string if is_little_endian: endian_chr = "<" else: endian_chr = ">" # assign implicit VR struct to variable as use later if VR assumed missing implicit_VR_struct = Struct(endian_chr + "HHL") if is_implicit_VR: element_struct = implicit_VR_struct else: # Explicit VR # tag, VR, 2-byte length (or 0 if special VRs) element_struct = Struct(endian_chr + "HH2sH") extra_length_struct = Struct(endian_chr + "L") # for special VRs extra_length_unpack = extra_length_struct.unpack # for lookup speed # Make local variables so have faster lookup fp_read = fp.read fp_tell = fp.tell logger_debug = logger.debug debugging = config.debugging element_struct_unpack = element_struct.unpack defer_size = size_in_bytes(defer_size) tag_set = {Tag(tag) for tag in specific_tags} if specific_tags else set() has_tag_set = bool(tag_set) if has_tag_set: tag_set.add(Tag(0x00080005)) # Specific Character Set while True: # VR: Optional[str] # Read tag, VR, length, get ready to read value bytes_read = fp_read(8) if len(bytes_read) < 8: return # at end of file if debugging: debug_msg = f"{fp.tell() - 8:08x}: {bytes2hex(bytes_read)}" if is_implicit_VR: # must reset VR each time; could have set last iteration (e.g. SQ) VR = None group, elem, length = element_struct_unpack(bytes_read) else: # explicit VR group, elem, VR, length = element_struct_unpack(bytes_read) # defend against switching to implicit VR, some writer do in SQ's # issue 1067, issue 1035 if not (b'AA' <= VR <= b'ZZ') and config.assume_implicit_vr_switch: # invalid VR, must be 2 cap chrs, assume implicit and continue VR = None group, elem, length = implicit_VR_struct.unpack(bytes_read) else: VR = VR.decode(default_encoding) if VR in extra_length_VRs: bytes_read = fp_read(4) length = extra_length_unpack(bytes_read)[0] if debugging: debug_msg += " " + bytes2hex(bytes_read) if debugging: debug_msg = "%-47s (%04x, %04x)" % (debug_msg, group, elem) if not is_implicit_VR: debug_msg += " %s " % VR if length != 0xFFFFFFFF: debug_msg += "Length: %d" % length else: debug_msg += "Length: Undefined length (FFFFFFFF)" logger_debug(debug_msg) # Positioned to read the value, but may not want to -- check stop_when value_tell = fp_tell() tag = TupleTag((group, elem)) if stop_when is not None: # XXX VR may be None here!! Should stop_when just take tag? if stop_when(tag, VR, length): if debugging: logger_debug("Reading ended by stop_when callback. " "Rewinding to start of data element.") rewind_length = 8 if not is_implicit_VR and VR in extra_length_VRs: rewind_length += 4 fp.seek(value_tell - rewind_length) return # Reading the value # First case (most common): reading a value with a defined length if length != 0xFFFFFFFF: # don't defer loading of Specific Character Set value as it is # needed immediately to get the character encoding for other tags if has_tag_set and tag not in tag_set: # skip the tag if not in specific tags fp.seek(fp_tell() + length) continue if (defer_size is not None and length > defer_size and tag != BaseTag(0x00080005)): # Flag as deferred by setting value to None, and skip bytes value = None logger_debug("Defer size exceeded. " "Skipping forward to next data element.") fp.seek(fp_tell() + length) else: value = ( fp_read(length) if length > 0 else cast( Optional[bytes], empty_value_for_VR(VR, raw=True) ) ) if debugging: dotdot = "..." if length > 20 else " " displayed_value = value[:20] if value else b'' logger_debug("%08x: %-34s %s %r %s" % (value_tell, bytes2hex(displayed_value), dotdot, displayed_value, dotdot)) # If the tag is (0008,0005) Specific Character Set, then store it if tag == BaseTag(0x00080005): # *Specific Character String* is b'' for empty value encoding = convert_string( cast(bytes, value) or b'', is_little_endian ) # Store the encoding value in the generator # for use with future elements (SQs) encoding = convert_encodings(encoding) yield RawDataElement(tag, VR, length, value, value_tell, is_implicit_VR, is_little_endian) # Second case: undefined length - must seek to delimiter, # unless is SQ type, in which case is easier to parse it, because # undefined length SQs and items of undefined lengths can be nested # and it would be error-prone to read to the correct outer delimiter else: # VR UN with undefined length shall be handled as SQ # see PS 3.5, section 6.2.2 if VR == 'UN': VR = 'SQ' # Try to look up type to see if is a SQ # if private tag, won't be able to look it up in dictionary, # in which case just ignore it and read the bytes unless it is # identified as a Sequence if VR is None or VR == 'UN' and config.replace_un_with_known_vr: try: VR = dictionary_VR(tag) except KeyError: # Look ahead to see if it consists of items # and is thus a SQ next_tag = _unpack_tag(fp_read(4), endian_chr) # Rewind the file fp.seek(fp_tell() - 4) if next_tag == ItemTag: VR = 'SQ' if VR == 'SQ': if debugging: logger_debug( f"{fp_tell():08X}: Reading/parsing undefined length " "sequence" ) seq = read_sequence(fp, is_implicit_VR, is_little_endian, length, encoding) if has_tag_set and tag not in tag_set: continue yield DataElement(tag, VR, seq, value_tell, is_undefined_length=True) else: delimiter = SequenceDelimiterTag if debugging: logger_debug("Reading undefined length data element") value = read_undefined_length_value( fp, is_little_endian, delimiter, defer_size ) # tags with undefined length are skipped after read if has_tag_set and tag not in tag_set: continue yield RawDataElement(tag, VR, length, value, value_tell, is_implicit_VR, is_little_endian)
def test_eq_tuple(self): """Test __eq__ of tuple with BaseTag.""" assert BaseTag(0x00010002) == (0x0001, 0x0002) assert not BaseTag(0x00010001) == (0x0001, 0x0002)
def read_dataset(fp, is_implicit_VR, is_little_endian, bytelength=None, stop_when=None, defer_size=None, parent_encoding=default_encoding, specific_tags=None, at_top_level=True): """Return a :class:`~pydicom.dataset.Dataset` instance containing the next dataset in the file. Parameters ---------- fp : file-like An opened file-like object. is_implicit_VR : bool ``True`` if file transfer syntax is implicit VR. is_little_endian : bool ``True`` if file has little endian transfer syntax. bytelength : int, None, optional ``None`` to read until end of file or ItemDeliterTag, else a fixed number of bytes to read stop_when : None, optional Optional call_back function which can terminate reading. See help for :func:`data_element_generator` for details defer_size : int, None, optional Size to avoid loading large elements in memory. See :func:`dcmread` for more parameter info. parent_encoding : Optional encoding to use as a default in case (0008,0005) *Specific Character Set* isn't specified. specific_tags : list or None See :func:`dcmread` for parameter info. at_top_level: bool If dataset is top level (not within a sequence). Used to turn off explicit VR heuristic within sequences Returns ------- dataset.Dataset A Dataset instance. See Also -------- :class:`~pydicom.dataset.Dataset` A collection (dictionary) of DICOM :class:`~pydicom.dataelem.DataElement` instances. """ raw_data_elements = dict() fp_start = fp.tell() if at_top_level: is_implicit_VR = _is_implicit_vr(fp, is_implicit_VR, is_little_endian, stop_when) fp.seek(fp_start) de_gen = data_element_generator(fp, is_implicit_VR, is_little_endian, stop_when, defer_size, parent_encoding, specific_tags) try: while (bytelength is None) or (fp.tell() - fp_start < bytelength): raw_data_element = next(de_gen) # Read data elements. Stop on some errors, but return what was read tag = raw_data_element.tag # Check for ItemDelimiterTag --dataset is an item in a sequence if tag == BaseTag(0xFFFEE00D): break raw_data_elements[tag] = raw_data_element except StopIteration: pass except EOFError as details: if config.enforce_valid_values: raise msg = str(details) + " in file " + getattr(fp, "name", "<no filename>") warnings.warn(msg, UserWarning) except NotImplementedError as details: logger.error(details) ds = Dataset(raw_data_elements) if 0x00080005 in raw_data_elements: char_set = DataElement_from_raw(raw_data_elements[0x00080005]) encoding = convert_encodings(char_set) else: encoding = parent_encoding ds.set_original_encoding(is_implicit_VR, is_little_endian, encoding) return ds
def test_raise(): BaseTag(0x00010002) == 'eraa'
def test_raise(): BaseTag(0x00010002) >= 'AGHIJJJJ'
def test_ne_diff_class(self): """Test __ne__ of two classes with different type.""" assert not BaseTag(0x00000000) != 0 assert BaseTag(0x00000001) != 0
def test_gt_same_class(self): """Test __gt__ of two classes with same type.""" assert not BaseTag(0x00000000) > BaseTag(0x00000001) assert not BaseTag(0x00000001) > BaseTag(0x00000001) assert BaseTag(0x00000001) > BaseTag(0x00000000)
def test_raise(): BaseTag(0x00010002) != 'aaag'
def test_gt_diff_class(self): """Test __gt__ of two classes with different type.""" assert not BaseTag(0x00000000) > 1 assert not BaseTag(0x00000001) > 1 assert BaseTag(0x00000001) > 0
def test_str(self): """Test str(BaseTag) produces correct value.""" assert str(BaseTag(0x00000000)) == '(0000, 0000)' assert str(BaseTag(0x00010002)) == '(0001, 0002)' assert str(BaseTag(0x10002000)) == '(1000, 2000)' assert str(BaseTag(0xFFFFFFFE)) == '(ffff, fffe)'
def test_gt_tuple(self): """Test __gt__ of tuple with BaseTag.""" assert not BaseTag(0x00010001) > (0x0001, 0x0002) assert not BaseTag(0x00010002) > (0x0001, 0x0002) assert BaseTag(0x00010002) > (0x0001, 0x0001)
def test_element(self): """Test BaseTag.element returns correct values.""" assert BaseTag(0x00010000).element == 0x0000 assert BaseTag(0x00010002).element == 0x0002 assert BaseTag(0x0001FFFF).element == 0xFFFF
def test_raise(): BaseTag(0x00010002) > 'BLUH'
def test_le_tuple(self): """Test __le__ of tuple with BaseTag.""" assert BaseTag(0x00010001) <= (0x0001, 0x0002) assert BaseTag(0x00010002) <= (0x0001, 0x0002) assert not BaseTag(0x00010002) <= (0x0001, 0x0001)
def test_eq_same_class(self): """Test __eq__ of two classes with same type.""" assert BaseTag(0x00000000) == BaseTag(0x00000000) assert not BaseTag(0x00000001) == BaseTag(0x00000000)
def test_raise(): BaseTag(0x00010002) <= 'Somethin'
def test_ne_non_numeric(self): """Test __ne__ of non numeric with BaseTag.""" assert BaseTag(0x00010002) != 'aaag'