| #!/usr/bin/env python |
| # -*- coding: utf-8 -*- |
| """ |
| Test suite to test the :mod:`parse_type.parse_util` module. |
| """ |
| |
| from __future__ import absolute_import, print_function |
| from .parse_type_test import TestCase, unittest |
| from parse_type.parse_util \ |
| import Field, FieldParser, FormatSpec, make_format_spec |
| |
| |
| # ----------------------------------------------------------------------------- |
| # TEST CASE: |
| # ----------------------------------------------------------------------------- |
| class TestField(TestCase): |
| EMPTY_FORMAT_FIELDS = [ |
| Field(), #< Empty field. |
| Field("name"), #< Named field without format. |
| Field("name", ""), #< Named field with format=empty-string. |
| Field(format=""), #< Field with format=empty-string. |
| ] |
| NONEMPTY_FORMAT_FIELDS = [ |
| Field(format="Number"), #< Typed field without name". |
| Field("name", "Number"), #< Named and typed field". |
| ] |
| INVALID_FORMAT_FIELDS = [ |
| Field(format="<"), #< Align without type. |
| Field(format="_<"), #< Fill and align without type. |
| Field(format="_<10"), #< Fill, align and width without type. |
| Field(format="_<098"), #< Fill, align, zero and width without type. |
| ] |
| FIELDS = EMPTY_FORMAT_FIELDS + NONEMPTY_FORMAT_FIELDS + INVALID_FORMAT_FIELDS |
| |
| def test_is_typed__returns_true_for_nonempty_format(self): |
| fields = self.NONEMPTY_FORMAT_FIELDS + self.INVALID_FORMAT_FIELDS |
| for field in fields: |
| self.assertTrue(field.has_format, "Field: %s" % field) |
| |
| def test_is_typed__returns_false_for_empty_format(self): |
| fields = self.EMPTY_FORMAT_FIELDS |
| for field in fields: |
| self.assertFalse(field.has_format, "Field: %s" % field) |
| |
| def test_format_spec__returns_none_if_format_is_empty(self): |
| for field in self.EMPTY_FORMAT_FIELDS: |
| self.assertIsNone(field.format_spec, "Field: %s" % field) |
| |
| def test_format_spec__if_format_is_nonempty_and_valid(self): |
| for field in self.NONEMPTY_FORMAT_FIELDS: |
| self.assertIsNotNone(field.format_spec) |
| self.assertIsInstance(field.format_spec, FormatSpec) |
| |
| def test_format_spec__raises_error_if_nonempty_format_is_invalid(self): |
| for field in self.INVALID_FORMAT_FIELDS: |
| with self.assertRaises(ValueError): |
| field.format_spec |
| |
| def test_format_spec__is_lazy_evaluated(self): |
| fields = [Field(), Field("name"), |
| Field("name", "type"), Field(format="type")] |
| for field in fields: |
| self.assertIsNone(field._format_spec) |
| if field.format: |
| _ = field.format_spec.type |
| self.assertIsNotNone(field.format_spec) |
| else: |
| self.assertIsNone(field.format_spec) |
| |
| def test_set_format_invalidates_format_spec(self): |
| field = Field(format="Number") |
| self.assertEqual(field.format, "Number") |
| self.assertEqual(field.format_spec.type, "Number") |
| self.assertEqual(field.format_spec.align, None) |
| |
| field.set_format("<ManyNumbers") |
| self.assertEqual(field.format, "<ManyNumbers") |
| self.assertEqual(field.format_spec.type, "ManyNumbers") |
| self.assertEqual(field.format_spec.align, '<') |
| |
| def test_to_string_conversion(self): |
| test_data = [ |
| (Field(), "{}"), |
| (Field("name"), "{name}"), |
| (Field(format="type"), "{:type}"), |
| (Field("name", "type"), "{name:type}"), |
| ] |
| for field, expected_text in test_data: |
| text = str(field) |
| self.assertEqual(text, expected_text) |
| |
| def test_equal__with_field(self): |
| for field in self.FIELDS: |
| other = field |
| self.assertEqual(field, other) |
| |
| def test_equal__with_string(self): |
| for field in self.FIELDS: |
| other = str(field) |
| self.assertEqual(field, other) |
| |
| def test_equal__with_unsupported(self): |
| UNSUPPORTED_TYPES = [None, make_format_spec(), True, False, 10] |
| field = Field() |
| for other in UNSUPPORTED_TYPES: |
| with self.assertRaises(ValueError): |
| field == other |
| |
| def test_not_equal__with_field(self): |
| for field in self.FIELDS: |
| other2 = Field(field.name, "XXX") |
| self.assertNotEqual(field.format, other2.format) |
| self.assertNotEqual(field, other2) |
| |
| other3 = Field("xxx", field.format) |
| self.assertNotEqual(field.name, other3.name) |
| self.assertNotEqual(field, other3) |
| |
| def test_not_equal__with_string(self): |
| for field in self.FIELDS: |
| other2 = Field(field.name, "XXX") |
| other2_text = str(other2) |
| self.assertNotEqual(field.format, other2.format) |
| self.assertNotEqual(field, other2_text) |
| |
| other3 = Field("xxx", field.format) |
| other3_text = str(other3) |
| self.assertNotEqual(field.name, other3.name) |
| self.assertNotEqual(field, other3_text) |
| |
| def test_not_equal__with_unsupported(self): |
| UNSUPPORTED_TYPES = [None, make_format_spec(), True, False, 10] |
| field = Field() |
| for other in UNSUPPORTED_TYPES: |
| with self.assertRaises(ValueError): |
| field != other |
| |
| |
| # ----------------------------------------------------------------------------- |
| # TEST CASE: |
| # ----------------------------------------------------------------------------- |
| class TestFieldFormatSpec(TestCase): |
| """ |
| Test Field.extract_format_spec(). |
| |
| FORMAT-SPEC SCHEMA: |
| [[fill]align][0][width][.precision][type] |
| """ |
| |
| def assertValidFormatWidth(self, width): |
| self.assertIsInstance(width, str) |
| for char in width: |
| self.assertTrue(char.isdigit()) |
| |
| def assertValidFormatAlign(self, align): |
| self.assertIsInstance(align, str) |
| self.assertEqual(len(align), 1) |
| self.assertIn(align, Field.ALIGN_CHARS) |
| |
| def assertValidFormatPrecision(self, precision): |
| self.assertIsInstance(precision, str) |
| for char in precision: |
| self.assertTrue(char.isdigit()) |
| |
| def test_extract_format_spec__with_empty_string_raises_error(self): |
| with self.assertRaises(ValueError) as cm: |
| Field.extract_format_spec("") |
| self.assertIn("INVALID-FORMAT", str(cm.exception)) |
| |
| def test_extract_format_spec__with_type(self): |
| format_types = ["d", "w", "Number", "Number?", "Number*", "Number+"] |
| for format_type in format_types: |
| format_spec = Field.extract_format_spec(format_type) |
| expected_spec = make_format_spec(format_type) |
| self.assertEqual(format_spec.type, format_type) |
| self.assertEqual(format_spec.width, "") |
| self.assertEqual(format_spec.zero, False) |
| self.assertIsNone(format_spec.align) |
| self.assertIsNone(format_spec.fill) |
| self.assertEqual(format_spec, expected_spec) |
| |
| def test_extract_format_spec_with_width_only_raises_error(self): |
| # -- INVALID-FORMAT: Width without type. |
| with self.assertRaises(ValueError) as cm: |
| Field.extract_format_spec("123") |
| self.assertEqual("INVALID-FORMAT: 123 (without type)", str(cm.exception)) |
| |
| def test_extract_format_spec__with_zero_only_raises_error(self): |
| # -- INVALID-FORMAT: Width without type. |
| with self.assertRaises(ValueError) as cm: |
| Field.extract_format_spec("0") |
| self.assertEqual("INVALID-FORMAT: 0 (without type)", str(cm.exception)) |
| |
| def test_extract_format_spec__with_align_only_raises_error(self): |
| # -- INVALID-FORMAT: Width without type. |
| for align in Field.ALIGN_CHARS: |
| with self.assertRaises(ValueError) as cm: |
| Field.extract_format_spec(align) |
| self.assertEqual("INVALID-FORMAT: %s (without type)" % align, |
| str(cm.exception)) |
| |
| def test_extract_format_spec_with_fill_and_align_only_raises_error(self): |
| # -- INVALID-FORMAT: Width without type. |
| fill = "_" |
| for align in Field.ALIGN_CHARS: |
| with self.assertRaises(ValueError) as cm: |
| format = fill + align |
| Field.extract_format_spec(format) |
| self.assertEqual("INVALID-FORMAT: %s (without type)" % format, |
| str(cm.exception)) |
| |
| def test_extract_format_spec__with_width_and_type(self): |
| formats = ["1s", "2d", "6s", "10d", "60f", "123456789s"] |
| for format in formats: |
| format_spec = Field.extract_format_spec(format) |
| expected_type = format[-1] |
| expected_width = format[:-1] |
| expected_spec = make_format_spec(type=expected_type, |
| width=expected_width) |
| self.assertEqual(format_spec, expected_spec) |
| self.assertValidFormatWidth(format_spec.width) |
| |
| def test_extract_format_spec__with_precision_and_type(self): |
| formats = [".2d", ".6s", ".6f"] |
| for format in formats: |
| format_spec = Field.extract_format_spec(format) |
| expected_type = format[-1] |
| expected_precision = format[1:-1] |
| expected_spec = make_format_spec(type=expected_type, |
| precision=expected_precision) |
| self.assertEqual(format_spec, expected_spec) |
| self.assertValidFormatPrecision(format_spec.precision) |
| |
| def test_extract_format_spec__with_zero_and_type(self): |
| formats = ["0s", "0d", "0Number", "0Number+"] |
| for format in formats: |
| format_spec = Field.extract_format_spec(format) |
| expected_type = format[1:] |
| expected_spec = make_format_spec(type=expected_type, zero=True) |
| self.assertEqual(format_spec, expected_spec) |
| |
| def test_extract_format_spec__with_align_and_type(self): |
| # -- ALIGN_CHARS = "<>=^" |
| formats = ["<s", ">d", "=Number", "^Number+"] |
| for format in formats: |
| format_spec = Field.extract_format_spec(format) |
| expected_align = format[0] |
| expected_type = format[1:] |
| expected_spec = make_format_spec(type=expected_type, |
| align=expected_align) |
| self.assertEqual(format_spec, expected_spec) |
| self.assertValidFormatAlign(format_spec.align) |
| |
| def test_extract_format_spec__with_fill_align_and_type(self): |
| # -- ALIGN_CHARS = "<>=^" |
| formats = ["X<s", "_>d", "0=Number", " ^Number+"] |
| for format in formats: |
| format_spec = Field.extract_format_spec(format) |
| expected_fill = format[0] |
| expected_align = format[1] |
| expected_type = format[2:] |
| expected_spec = make_format_spec(type=expected_type, |
| align=expected_align, fill=expected_fill) |
| self.assertEqual(format_spec, expected_spec) |
| self.assertValidFormatAlign(format_spec.align) |
| |
| # -- ALIGN_CHARS = "<>=^" |
| FORMAT_AND_FORMAT_SPEC_DATA = [ |
| ("^010Number+", make_format_spec(type="Number+", width="10", |
| zero=True, align="^", fill=None)), |
| ("X<010Number+", make_format_spec(type="Number+", width="10", |
| zero=True, align="<", fill="X")), |
| ("_>0098Number?", make_format_spec(type="Number?", width="098", |
| zero=True, align=">", fill="_")), |
| ("*=129Number*", make_format_spec(type="Number*", width="129", |
| zero=False, align="=", fill="*")), |
| ("X129Number?", make_format_spec(type="X129Number?", width="", |
| zero=False, align=None, fill=None)), |
| (".3Number", make_format_spec(type="Number", width="", |
| zero=False, align=None, fill=None, |
| precision="3")), |
| ("6.2Number", make_format_spec(type="Number", width="6", |
| zero=False, align=None, fill=None, |
| precision="2")), |
| ] |
| |
| def test_extract_format_spec__with_all(self): |
| for format, expected_spec in self.FORMAT_AND_FORMAT_SPEC_DATA: |
| format_spec = Field.extract_format_spec(format) |
| self.assertEqual(format_spec, expected_spec) |
| self.assertValidFormatWidth(format_spec.width) |
| if format_spec.align is not None: |
| self.assertValidFormatAlign(format_spec.align) |
| |
| def test_make_format(self): |
| for expected_format, format_spec in self.FORMAT_AND_FORMAT_SPEC_DATA: |
| format = Field.make_format(format_spec) |
| self.assertEqual(format, expected_format) |
| format_spec2 = Field.extract_format_spec(format) |
| self.assertEqual(format_spec2, format_spec) |
| |
| |
| # ----------------------------------------------------------------------------- |
| # TEST CASE: |
| # ----------------------------------------------------------------------------- |
| class TestFieldParser(TestCase): |
| INVALID_FIELDS = ["", "{", "}", "xxx", "name:type", ":type"] |
| VALID_FIELD_DATA = [ |
| ("{}", Field()), |
| ("{name}", Field("name")), |
| ("{:type}", Field(format="type")), |
| ("{name:type}", Field("name", "type")) |
| ] |
| |
| #def assertFieldEqual(self, actual, expected): |
| # message = "FAILED: %s == %s" % (actual, expected) |
| # self.assertIsInstance(actual, Field) |
| # self.assertIsInstance(expected, Field) |
| # self.assertEqual(actual, expected, message) |
| # # self.assertEqual(actual.name, expected.name, message) |
| # # self.assertEqual(actual.format, expected.format, message) |
| |
| def test_parse__raises_error_with_missing_or_partial_braces(self): |
| for field_text in self.INVALID_FIELDS: |
| with self.assertRaises(ValueError): |
| FieldParser.parse(field_text) |
| |
| def test_parse__with_valid_fields(self): |
| for field_text, expected_field in self.VALID_FIELD_DATA: |
| field = FieldParser.parse(field_text) |
| self.assertEqual(field, expected_field) |
| |
| def test_extract_fields__without_field(self): |
| prefix = "XXX ___" |
| suffix = "XXX {{escaped_field}} {{escaped_field:xxx_type}} XXX" |
| field_texts = [prefix, suffix, prefix + suffix, suffix + prefix] |
| |
| for field_text in field_texts: |
| fields = list(FieldParser.extract_fields(field_text)) |
| self.assertEqual(len(fields), 0) |
| |
| def test_extract_fields__with_one_field(self): |
| prefix = "XXX ___" |
| suffix = "XXX {{escaped_field}} {{escaped_field:xxx_type}} XXX" |
| |
| for field_text, expected_field in self.VALID_FIELD_DATA: |
| fields = list(FieldParser.extract_fields(field_text)) |
| self.assertEqual(len(fields), 1) |
| self.assertSequenceEqual(fields, [expected_field]) |
| |
| field_text2 = prefix + field_text + suffix |
| fields2 = list(FieldParser.extract_fields(field_text2)) |
| self.assertEqual(len(fields2), 1) |
| self.assertSequenceEqual(fields, fields2) |
| |
| def test_extract_fields__with_many_fields(self): |
| MANY_FIELDS_DATA = [ |
| ("{}xxx{name2}", [Field(), Field("name2")]), |
| ("{name1}yyy{:type2}", [Field("name1"), Field(format="type2")]), |
| ("{:type1}xxx{name2}{name3:type3}", |
| [Field(format="type1"), Field("name2"), Field("name3", "type3")]), |
| ] |
| prefix = "XXX ___" |
| suffix = "XXX {{escaped_field}} {{escaped_field:xxx_type}} XXX" |
| |
| for field_text, expected_fields in MANY_FIELDS_DATA: |
| fields = list(FieldParser.extract_fields(field_text)) |
| self.assertEqual(len(fields), len(expected_fields)) |
| self.assertSequenceEqual(fields, expected_fields) |
| |
| field_text2 = prefix + field_text + suffix |
| fields2 = list(FieldParser.extract_fields(field_text2)) |
| self.assertEqual(len(fields2), len(expected_fields)) |
| self.assertSequenceEqual(fields2, expected_fields) |
| |
| |
| def test_extract_types(self): |
| MANY_TYPES_DATA = [ |
| ("{}xxx{name2}", []), |
| ("{name1}yyy{:type2}", ["type2"]), |
| ("{:type1}xxx{name2}{name3:type3}", ["type1", "type3"]), |
| ] |
| |
| for field_text, expected_types in MANY_TYPES_DATA: |
| type_names = list(FieldParser.extract_types(field_text)) |
| self.assertEqual(len(type_names), len(expected_types)) |
| self.assertSequenceEqual(type_names, expected_types) |
| |
| |
| # ----------------------------------------------------------------------------- |
| # MAIN: |
| # ----------------------------------------------------------------------------- |
| if __name__ == '__main__': |
| unittest.main() |
| |
| |
| # Copyright (c) 2012-2013 by Jens Engel (https://github/jenisys/parse_type) |
| # |
| # Permission is hereby granted, free of charge, to any person obtaining a copy |
| # of this software and associated documentation files (the "Software"), to deal |
| # in the Software without restriction, including without limitation the rights |
| # to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
| # copies of the Software, and to permit persons to whom the Software is |
| # furnished to do so, subject to the following conditions: |
| # |
| # The above copyright notice and this permission notice shall be included in |
| # all copies or substantial portions of the Software. |
| # |
| # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| # IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| # FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
| # AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| # LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
| # OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
| # SOFTWARE. |
