Coverage for test/test.py: 100%

1# Copyright 2017-2023 Louis Paternault 

2# 

3# This program is free software: you can redistribute it and/or modify 

4# it under the terms of the GNU General Public License as published by 

5# the Free Software Foundation, either version 3 of the License, or 

6# (at your option) any later version. 

7# 

8# This program is distributed in the hope that it will be useful, 

9# but WITHOUT ANY WARRANTY; without even the implied warranty of 

10# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 

11# GNU General Public License for more details. 

12# 

13# You should have received a copy of the GNU General Public License 

14# along with this program. If not, see <http://www.gnu.org/licenses/>. 

15 

16"""Tests""" 

17 

18 

19import unittest 

20from decimal import Decimal 

21 

22import papersize 

23 

24 

25class TestDefinition(unittest.TestCase): 

26 """Test format definitions.""" 

27 

28 # pylint: disable = invalid-name 

29 

30 def testValidDefinitions(self): 

31 """Test that :data:`papersize.SIZES` is correctly defined.""" 

32 for key, value in papersize.SIZES.items(): 

33 self.assertEqual( 

34 papersize.parse_papersize(key), papersize.parse_papersize(value) 

35 ) 

36 

37 

38class TestParse(unittest.TestCase): 

39 """Test parsing related functions.""" 

40 

41 # pylint: disable = invalid-name 

42 

43 def assertIterAlmostEqual(self, iter1, iter2): 

44 """Assert iterators of elements are almost items. 

45 

46 Both arguments are expected to be iterators of the same size, and 

47 iterators with the same indexes are checked to be almost equal. 

48 """ 

49 

50 for left, right in zip(iter1, iter2): 

51 self.assertAlmostEqual(Decimal(left), Decimal(right)) 

52 

53 def testExceptions(self): 

54 """Test module exceptions""" 

55 try: 

56 papersize.parse_length("cm") 

57 except papersize.CouldNotParse as error: 

58 self.assertEqual(str(error), "Could not parse string 'cm'.") 

59 

60 try: 

61 papersize.rotate((1, 2), "portrait") 

62 except papersize.UnknownOrientation as error: 

63 self.assertEqual( 

64 str(error), 

65 "'portrait' is not one of `papersize.PORTRAIT` or `papersize.LANDSCAPE`", 

66 ) 

67 

68 def testParseLength(self): 

69 """Test :func:`papersize.parse_length`.""" 

70 for args, result in [(("10cm", "mm"), 100), (("10in",), 722.7)]: 

71 self.assertAlmostEqual(papersize.parse_length(*args), Decimal(result)) 

72 

73 self.assertRaises(papersize.CouldNotParse, papersize.parse_length, "cm") 

74 

75 def testParseCouple(self): 

76 """Test :func:`papersize.parse_couple`.""" 

77 for args, result in [ 

78 (("10cmx1mm",), (284.5275591, 2.845275591)), 

79 (("10cmx1mm", "mm"), (100, 1)), 

80 (("10cm 1mm", "mm"), (100, 1)), 

81 (("10cm×1mm", "mm"), (100, 1)), 

82 (("2pc x 3pt", "pt"), (24, 3)), 

83 (("2cc x 3dd", "dd"), (24, 3)), 

84 ]: 

85 with self.subTest(args=args, result=result): 

86 self.assertIterAlmostEqual(papersize.parse_couple(*args), result) 

87 

88 self.assertRaises( 

89 papersize.CouldNotParse, papersize.parse_papersize, "2cmx2cm 2cm" 

90 ) 

91 

92 def testParsePaperSize(self): 

93 """Test :func:`papersize.parse_papersize`.""" 

94 for args, result in [ 

95 (("A4", "cm"), (21, 29.7)), 

96 (("20cm x 1mm", "cm"), (20, 0.1)), 

97 (("Ledger",), (1228.59, 794.97)), 

98 ]: 

99 self.assertIterAlmostEqual(papersize.parse_papersize(*args), result) 

100 

101 self.assertRaises( 

102 papersize.CouldNotParse, papersize.parse_papersize, "Hello, world!" 

103 ) 

104 

105 def testConvertLength(self): 

106 """Test :func:`papersize.convert_length`.""" 

107 for args, result in [((10, "cm", "mm"), 100), ((1, "mm", "pt"), 2.845275591)]: 

108 self.assertAlmostEqual(papersize.convert_length(*args), Decimal(result)) 

109 

110 

111class TestOrientation(unittest.TestCase): 

112 """Test orientation related tools.""" 

113 

114 # pylint: disable = invalid-name 

115 

116 def testPortraitLandscape(self): 

117 """Test portrait/landscape functions.""" 

118 self.assertTrue(papersize.is_portrait(10, 11)) 

119 self.assertTrue(papersize.is_portrait(10, 10)) 

120 self.assertFalse(papersize.is_portrait(11, 10)) 

121 

122 self.assertFalse(papersize.is_landscape(10, 11)) 

123 self.assertTrue(papersize.is_landscape(10, 10)) 

124 self.assertTrue(papersize.is_landscape(11, 10)) 

125 

126 self.assertFalse(papersize.is_square(10, 11)) 

127 self.assertTrue(papersize.is_square(10, 10)) 

128 self.assertFalse(papersize.is_square(11, 10)) 

129 

130 def testStrictFuzzy(self): 

131 """Test strict and fuzzy options.""" 

132 # Test strict 

133 self.assertTrue(papersize.is_landscape(10, 10, strict=False)) 

134 self.assertTrue(papersize.is_portrait(10, 10, strict=False)) 

135 self.assertFalse(papersize.is_landscape(10, 10, strict=True)) 

136 self.assertFalse(papersize.is_portrait(10, 10, strict=True)) 

137 self.assertTrue(papersize.is_landscape(10, 10)) 

138 self.assertTrue(papersize.is_portrait(10, 10)) 

139 

140 # Test fuzzy 

141 self.assertTrue(papersize.is_square(1, 1.000000001, fuzzy=True)) 

142 self.assertFalse(papersize.is_square(1, 1.000000001, fuzzy=False)) 

143 self.assertTrue(papersize.is_portrait(1.000000001, 1, fuzzy=True)) 

144 self.assertFalse(papersize.is_portrait(1.000000001, 1, fuzzy=False)) 

145 self.assertTrue(papersize.is_landscape(1, 1.000000001, fuzzy=True)) 

146 self.assertFalse(papersize.is_landscape(1, 1.000000001, fuzzy=False)) 

147 

148 # Test fuzzy and ndigits 

149 self.assertFalse(papersize.is_square(1, 1.000000001, fuzzy=True, ndigits=10)) 

150 self.assertFalse(papersize.is_square(1, 1.000000001, fuzzy=False, ndigits=10)) 

151 self.assertFalse(papersize.is_portrait(1.000000001, 1, fuzzy=True, ndigits=10)) 

152 self.assertFalse(papersize.is_portrait(1.000000001, 1, fuzzy=False, ndigits=10)) 

153 self.assertFalse(papersize.is_landscape(1, 1.000000001, fuzzy=True, ndigits=10)) 

154 self.assertFalse( 

155 papersize.is_landscape(1, 1.000000001, fuzzy=False, ndigits=10) 

156 ) 

157 

158 # Test strict and fuzzy 

159 self.assertTrue(papersize.is_square(1, 1.000000001, fuzzy=True)) 

160 self.assertFalse(papersize.is_square(1, 1.000000001, fuzzy=False)) 

161 self.assertTrue(papersize.is_square(1.000000001, 1, fuzzy=True)) 

162 self.assertFalse(papersize.is_square(1.000000001, 1, fuzzy=False)) 

163 

164 def testRotate(self): 

165 """Test :func:`papersize.rotate` function.""" 

166 self.assertEqual(papersize.rotate((10, 11), True), (10, 11)) 

167 self.assertEqual(papersize.rotate((10, 11), False), (11, 10)) 

168 

169 self.assertRaises( 

170 papersize.UnknownOrientation, papersize.rotate, (1, 2), "portrait" 

171 ) 

172 

173 

174class TestHelp(unittest.TestCase): 

175 """Test that every unit or paper format are described""" 

176 

177 # pylint: disable = invalid-name 

178 

179 def testHelpUnits(self): 

180 """Test that units are correctly described""" 

181 self.assertSetEqual( 

182 {unit.lower() for unit in papersize.UNITS if unit}, 

183 {unit.lower() for unit in papersize.UNITS_HELP}, 

184 ) 

185 

186 def testSizesHelp(self): 

187 """Test that sizes are correctly described""" 

188 self.assertSetEqual( 

189 {size.lower() for size in papersize.SIZES if size}, 

190 {size.lower() for size in papersize.SIZES_HELP}, 

191 )