test/test_acls.py

   1 #
   2 #
   3
   4 """Unittests for the posix1e module"""
   5
   6 #  Copyright (C) 2002-2009, 2012, 2014, 2015 Iustin Pop <iustin@k1024.org>
   7 #
   8 #  This library is free software; you can redistribute it and/or
   9 #  modify it under the terms of the GNU Lesser General Public
  10 #  License as published by the Free Software Foundation; either
  11 #  version 2.1 of the License, or (at your option) any later version.
  12 #
  13 #  This library is distributed in the hope that it will be useful,
  14 #  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16 #  Lesser General Public License for more details.
  17 #
  18 #  You should have received a copy of the GNU Lesser General Public
  19 #  License along with this library; if not, write to the Free Software
  20 #  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  21 #  02110-1301  USA
  22
  23
  24 import unittest
  25 import os
  26 import tempfile
  27 import sys
  28 import platform
  29 import re
  30 import errno
  31 import operator
  32
  33 import posix1e
  34 from posix1e import *
  35
  36 try:
  37   import __pypy__
  38 except ImportError:
  39   __pypy__ = None
  40
  41 TEST_DIR = os.environ.get("TEST_DIR", ".")
  42
  43 BASIC_ACL_TEXT = "u::rw,g::r,o::-"
  44
  45 # This is to workaround python 2/3 differences at syntactic level
  46 # (which can't be worked around via if's)
  47 M0500 = 320 # octal 0500
  48 M0644 = 420 # octal 0644
  49 M0755 = 493 # octal 755
  50
  51 # Permset permission information
  52 PERMSETS = {
  53   posix1e.ACL_READ: ("read", posix1e.Permset.read),
  54   posix1e.ACL_WRITE: ("write", posix1e.Permset.write),
  55   posix1e.ACL_EXECUTE: ("execute", posix1e.Permset.execute),
  56   }
  57
  58
  59 # Check if running under Python 3
  60 IS_PY_3K = sys.hexversion >= 0x03000000
  61
  62 def ignore_ioerror(errnum, fn, *args, **kwargs):
  63     """Call a function while ignoring some IOErrors.
  64
  65     This is needed as some OSes (e.g. FreeBSD) return failure (EINVAL)
  66     when doing certain operations on an invalid ACL.
  67
  68     """
  69     try:
  70         fn(*args, **kwargs)
  71     except IOError:
  72         err = sys.exc_info()[1]
  73         if err.errno == errnum:
  74             return
  75         raise
  76
  77 def encode(s):
  78     """Encode a string if needed (under Python 3)"""
  79     if IS_PY_3K:
  80         return s.encode()
  81     else:
  82         return s
  83
  84
  85 class aclTest:
  86     """Support functions ACLs"""
  87
  88     def setUp(self):
  89         """set up function"""
  90         self.rmfiles = []
  91         self.rmdirs = []
  92
  93     def tearDown(self):
  94         """tear down function"""
  95         for fname in self.rmfiles:
  96             os.unlink(fname)
  97         for dname in self.rmdirs:
  98             os.rmdir(dname)
  99
 100     def _getfile(self):
 101         """create a temp file"""
 102         fh, fname = tempfile.mkstemp(".test", "xattr-", TEST_DIR)
 103         self.rmfiles.append(fname)
 104         return fh, fname
 105
 106     def _getdir(self):
 107         """create a temp dir"""
 108         dname = tempfile.mkdtemp(".test", "xattr-", TEST_DIR)
 109         self.rmdirs.append(dname)
 110         return dname
 111
 112     def _getsymlink(self):
 113         """create a symlink"""
 114         fh, fname = self._getfile()
 115         os.close(fh)
 116         os.unlink(fname)
 117         os.symlink(fname + ".non-existent", fname)
 118         return fname
 119
 120
 121 class LoadTests(aclTest, unittest.TestCase):
 122     """Load/create tests"""
 123     def testFromFile(self):
 124         """Test loading ACLs from a file"""
 125         _, fname = self._getfile()
 126         acl1 = posix1e.ACL(file=fname)
 127         self.assertTrue(acl1.valid(), "ACL read from file should be valid")
 128
 129     def testFromDir(self):
 130         """Test loading ACLs from a directory"""
 131         dname = self._getdir()
 132         acl1 = posix1e.ACL(file=dname)
 133         acl2 = posix1e.ACL(filedef=dname)
 134         self.assertTrue(acl1.valid(),
 135                         "ACL read from directory should be valid")
 136         # default ACLs might or might not be valid; missing ones are
 137         # not valid, so we don't test acl2 for validity
 138
 139     def testFromFd(self):
 140         """Test loading ACLs from a file descriptor"""
 141         fd, _ = self._getfile()
 142         acl1 = posix1e.ACL(fd=fd)
 143         self.assertTrue(acl1.valid(), "ACL read from fd should be valid")
 144
 145     def testFromEmpty(self):
 146         """Test creating an empty ACL"""
 147         acl1 = posix1e.ACL()
 148         self.assertFalse(acl1.valid(), "Empty ACL should not be valid")
 149
 150     def testFromText(self):
 151         """Test creating an ACL from text"""
 152         acl1 = posix1e.ACL(text=BASIC_ACL_TEXT)
 153         self.assertTrue(acl1.valid(),
 154                         "ACL based on standard description should be valid")
 155
 156     def testFromACL(self):
 157         """Test creating an ACL from an existing ACL"""
 158         acl1 = posix1e.ACL()
 159         acl2 = posix1e.ACL(acl=acl1)
 160
 161     def testInvalidCreationParams(self):
 162         """Test that creating an ACL from multiple objects fails"""
 163         fd, _ = self._getfile()
 164         self.assertRaises(ValueError, posix1e.ACL, text=BASIC_ACL_TEXT, fd=fd)
 165
 166     def testInvalidValueCreation(self):
 167         """Test that creating an ACL from wrong specification fails"""
 168         self.assertRaises(EnvironmentError, posix1e.ACL, text="foobar")
 169         self.assertRaises(TypeError, posix1e.ACL, foo="bar")
 170
 171     def testDoubleInit(self):
 172         acl1 = posix1e.ACL(text=BASIC_ACL_TEXT)
 173         self.assertTrue(acl1.valid())
 174         acl1.__init__(text=BASIC_ACL_TEXT)
 175         self.assertTrue(acl1.valid())
 176
 177 class AclExtensions(aclTest, unittest.TestCase):
 178     """ACL extensions checks"""
 179
 180     @unittest.skipUnless(HAS_ACL_FROM_MODE, "Missing HAS_ACL_FROM_MODE")
 181     def testFromMode(self):
 182         """Test loading ACLs from an octal mode"""
 183         acl1 = posix1e.ACL(mode=M0644)
 184         self.assertTrue(acl1.valid(),
 185                         "ACL created via octal mode shoule be valid")
 186
 187     @unittest.skipUnless(HAS_ACL_CHECK, "ACL check not supported")
 188     def testAclCheck(self):
 189         """Test the acl_check method"""
 190         acl1 = posix1e.ACL(text=BASIC_ACL_TEXT)
 191         self.assertFalse(acl1.check(), "ACL is not valid")
 192         acl2 = posix1e.ACL()
 193         self.assertTrue(acl2.check(), "Empty ACL should not be valid")
 194
 195     @unittest.skipUnless(HAS_EXTENDED_CHECK, "Extended ACL check not supported")
 196     def testExtended(self):
 197         """Test the acl_extended function"""
 198         fd, fname = self._getfile()
 199         basic_acl = posix1e.ACL(text=BASIC_ACL_TEXT)
 200         basic_acl.applyto(fd)
 201         for item in fd, fname:
 202             self.assertFalse(has_extended(item),
 203                              "A simple ACL should not be reported as extended")
 204         enhanced_acl = posix1e.ACL(text="u::rw,g::-,o::-,u:root:rw,mask::r")
 205         self.assertTrue(enhanced_acl.valid(),
 206                         "Failure to build an extended ACL")
 207         enhanced_acl.applyto(fd)
 208         for item in fd, fname:
 209             self.assertTrue(has_extended(item),
 210                             "An extended ACL should be reported as such")
 211
 212     @unittest.skipUnless(HAS_EXTENDED_CHECK, "Extended ACL check not supported")
 213     def testExtendedArgHandling(self):
 214       self.assertRaises(TypeError, has_extended)
 215       self.assertRaises(TypeError, has_extended, object())
 216
 217     @unittest.skipUnless(HAS_EQUIV_MODE, "equiv_mode not supported")
 218     def testEquivMode(self):
 219         """Test the equiv_mode function"""
 220         if HAS_ACL_FROM_MODE:
 221             for mode in M0644, M0755:
 222                 acl = posix1e.ACL(mode=mode)
 223                 self.assertEqual(acl.equiv_mode(), mode)
 224         acl = posix1e.ACL(text="u::rw,g::r,o::r")
 225         self.assertEqual(acl.equiv_mode(), M0644)
 226         acl = posix1e.ACL(text="u::rx,g::-,o::-")
 227         self.assertEqual(acl.equiv_mode(), M0500)
 228
 229     @unittest.skipUnless(HAS_ACL_CHECK, "ACL check not supported")
 230     def testToAnyText(self):
 231         acl = posix1e.ACL(text=BASIC_ACL_TEXT)
 232         self.assertIn(encode("u::"),
 233                           acl.to_any_text(options=posix1e.TEXT_ABBREVIATE))
 234         self.assertIn(encode("user::"), acl.to_any_text())
 235
 236     @unittest.skipUnless(HAS_ACL_CHECK, "ACL check not supported")
 237     def testToAnyTextWrongArgs(self):
 238         acl = posix1e.ACL(text=BASIC_ACL_TEXT)
 239         self.assertRaises(TypeError, acl.to_any_text, foo="bar")
 240
 241
 242     @unittest.skipUnless(HAS_ACL_CHECK, "ACL check not supported")
 243     def testRichCompare(self):
 244         acl1 = posix1e.ACL(text="u::rw,g::r,o::r")
 245         acl2 = posix1e.ACL(acl=acl1)
 246         acl3 = posix1e.ACL(text="u::rw,g::rw,o::r")
 247         self.assertEqual(acl1, acl2)
 248         self.assertNotEqual(acl1, acl3)
 249         self.assertRaises(TypeError, operator.lt, acl1, acl2)
 250         self.assertRaises(TypeError, operator.ge, acl1, acl3)
 251         self.assertTrue(acl1 != True)
 252         self.assertFalse(acl1 == 1)
 253         self.assertRaises(TypeError, operator.gt, acl1, True)
 254
 255     @unittest.skipUnless(hasattr(posix1e.ACL, "__cmp__"), "__cmp__ is missing")
 256     @unittest.skipUnless(__pypy__ is None, "Disabled under pypy")
 257     def testCmp(self):
 258         acl1 = posix1e.ACL()
 259         self.assertRaises(TypeError, acl1.__cmp__, acl1)
 260
 261     def testApplyToWithWrongObject(self):
 262         acl1 = posix1e.ACL(text=BASIC_ACL_TEXT)
 263         self.assertTrue(acl1.valid())
 264         self.assertRaises(TypeError, acl1.applyto, object())
 265         self.assertRaises(TypeError, acl1.applyto, object(), object())
 266
 267     @unittest.skipUnless(HAS_ACL_ENTRY, "ACL entries not supported")
 268     def testAclIterator(self):
 269         acl = posix1e.ACL(text=BASIC_ACL_TEXT)
 270         #self.assertEqual(len(acl), 3)
 271         for entry in acl:
 272             self.assertIs(entry.parent, acl)
 273
 274
 275 class WriteTests(aclTest, unittest.TestCase):
 276     """Write tests"""
 277
 278     def testDeleteDefault(self):
 279         """Test removing the default ACL"""
 280         dname = self._getdir()
 281         posix1e.delete_default(dname)
 282
 283     @unittest.skipUnless(__pypy__ is None, "Disabled under pypy")
 284     def testDeleteDefaultWrongArg(self):
 285         self.assertRaises(TypeError, posix1e.delete_default, object())
 286
 287     def testReapply(self):
 288         """Test re-applying an ACL"""
 289         fd, fname = self._getfile()
 290         acl1 = posix1e.ACL(fd=fd)
 291         acl1.applyto(fd)
 292         acl1.applyto(fname)
 293         dname = self._getdir()
 294         acl2 = posix1e.ACL(file=fname)
 295         acl2.applyto(dname)
 296
 297
 298 @unittest.skipUnless(HAS_ACL_ENTRY, "ACL entries not supported")
 299 class ModificationTests(aclTest, unittest.TestCase):
 300     """ACL modification tests"""
 301
 302     def checkRef(self, obj):
 303         """Checks if a given obj has a 'sane' refcount"""
 304         if platform.python_implementation() == "PyPy":
 305             return
 306         ref_cnt = sys.getrefcount(obj)
 307         # FIXME: hardcoded value for the max ref count... but I've
 308         # seen it overflow on bad reference counting, so it's better
 309         # to be safe
 310         if ref_cnt < 2 or ref_cnt > 1024:
 311             self.fail("Wrong reference count, expected 2-1024 and got %d" %
 312                       ref_cnt)
 313
 314     def testStr(self):
 315         """Test str() of an ACL."""
 316         acl = posix1e.ACL(text=BASIC_ACL_TEXT)
 317         str_acl = str(acl)
 318         self.checkRef(str_acl)
 319
 320     def testAppend(self):
 321         """Test append a new Entry to the ACL"""
 322         acl = posix1e.ACL()
 323         e = acl.append()
 324         e.tag_type = posix1e.ACL_OTHER
 325         ignore_ioerror(errno.EINVAL, acl.calc_mask)
 326         str_format = str(e)
 327         self.checkRef(str_format)
 328         e2 = acl.append(e)
 329         ignore_ioerror(errno.EINVAL, acl.calc_mask)
 330         self.assertFalse(acl.valid())
 331
 332     def testWrongAppend(self):
 333         """Test append a new Entry to the ACL based on wrong object type"""
 334         acl = posix1e.ACL()
 335         self.assertRaises(TypeError, acl.append, object())
 336
 337     def testEntryCreation(self):
 338         acl = posix1e.ACL()
 339         e = posix1e.Entry(acl)
 340         ignore_ioerror(errno.EINVAL, acl.calc_mask)
 341         str_format = str(e)
 342         self.checkRef(str_format)
 343
 344     def testEntryFailedCreation(self):
 345         # Checks for partial initialisation and deletion on error
 346         # path.
 347         self.assertRaises(TypeError, posix1e.Entry, object())
 348
 349     def testDelete(self):
 350         """Test delete Entry from the ACL"""
 351         acl = posix1e.ACL()
 352         e = acl.append()
 353         e.tag_type = posix1e.ACL_OTHER
 354         ignore_ioerror(errno.EINVAL, acl.calc_mask)
 355         acl.delete_entry(e)
 356         ignore_ioerror(errno.EINVAL, acl.calc_mask)
 357
 358     def testDoubleDelete(self):
 359         """Test delete Entry from the ACL"""
 360         # This is not entirely valid/correct, since the entry object
 361         # itself is invalid after the first deletion, so we're
 362         # actually testing deleting an invalid object, not a
 363         # non-existing entry...
 364         acl = posix1e.ACL()
 365         e = acl.append()
 366         e.tag_type = posix1e.ACL_OTHER
 367         ignore_ioerror(errno.EINVAL, acl.calc_mask)
 368         acl.delete_entry(e)
 369         ignore_ioerror(errno.EINVAL, acl.calc_mask)
 370         self.assertRaises(EnvironmentError, acl.delete_entry, e)
 371
 372     # This currently fails as this deletion seems to be accepted :/
 373     @unittest.skip("Entry deletion is unreliable")
 374     def testDeleteInvalidEntry(self):
 375         """Test delete foreign Entry from the ACL"""
 376         acl1 = posix1e.ACL()
 377         acl2 = posix1e.ACL()
 378         e = acl1.append()
 379         e.tag_type = posix1e.ACL_OTHER
 380         ignore_ioerror(errno.EINVAL, acl1.calc_mask)
 381         self.assertRaises(EnvironmentError, acl2.delete_entry, e)
 382
 383     def testDeleteInvalidObject(self):
 384         """Test delete a non-Entry from the ACL"""
 385         acl = posix1e.ACL()
 386         self.assertRaises(TypeError, acl.delete_entry, object())
 387
 388     def testDoubleEntries(self):
 389         """Test double entries"""
 390         acl = posix1e.ACL(text=BASIC_ACL_TEXT)
 391         self.assertTrue(acl.valid(), "ACL is not valid")
 392         for tag_type in (posix1e.ACL_USER_OBJ, posix1e.ACL_GROUP_OBJ,
 393                          posix1e.ACL_OTHER):
 394             e = acl.append()
 395             e.tag_type = tag_type
 396             e.permset.clear()
 397             self.assertFalse(acl.valid(),
 398                 "ACL containing duplicate entries"
 399                 " should not be valid")
 400             acl.delete_entry(e)
 401
 402     def testMultipleGoodEntries(self):
 403         """Test multiple valid entries"""
 404         acl = posix1e.ACL(text=BASIC_ACL_TEXT)
 405         self.assertTrue(acl.valid(), "ACL is not valid")
 406         for tag_type in (posix1e.ACL_USER,
 407                          posix1e.ACL_GROUP):
 408             for obj_id in range(5):
 409                 e = acl.append()
 410                 e.tag_type = tag_type
 411                 e.qualifier = obj_id
 412                 e.permset.clear()
 413                 acl.calc_mask()
 414                 self.assertTrue(acl.valid(),
 415                     "ACL should be able to hold multiple"
 416                     " user/group entries")
 417
 418     def testMultipleBadEntries(self):
 419         """Test multiple invalid entries"""
 420         for tag_type in (posix1e.ACL_USER,
 421                          posix1e.ACL_GROUP):
 422             acl = posix1e.ACL(text=BASIC_ACL_TEXT)
 423             self.assertTrue(acl.valid(), "ACL built from standard description"
 424                                          " should be valid")
 425             e1 = acl.append()
 426             e1.tag_type = tag_type
 427             e1.qualifier = 0
 428             e1.permset.clear()
 429             acl.calc_mask()
 430             self.assertTrue(acl.valid(), "ACL should be able to add a"
 431                 " user/group entry")
 432             e2 = acl.append()
 433             e2.tag_type = tag_type
 434             e2.qualifier = 0
 435             e2.permset.clear()
 436             ignore_ioerror(errno.EINVAL, acl.calc_mask)
 437             self.assertFalse(acl.valid(), "ACL should not validate when"
 438                 " containing two duplicate entries")
 439             acl.delete_entry(e1)
 440             # FreeBSD trips over itself here and can't delete the
 441             # entry, even though it still exists.
 442             ignore_ioerror(errno.EINVAL, acl.delete_entry, e2)
 443
 444     def testCopy(self):
 445         acl = ACL()
 446         e1 = acl.append()
 447         e1.tag_type = ACL_USER
 448         p1 = e1.permset
 449         p1.clear()
 450         p1.read = True
 451         p1.write = True
 452         e2 = acl.append()
 453         e2.tag_type = ACL_GROUP
 454         p2 = e2.permset
 455         p2.clear()
 456         p2.read = True
 457         self.assertFalse(p2.write)
 458         e2.copy(e1)
 459         self.assertTrue(p2.write)
 460         self.assertEqual(e1.tag_type, e2.tag_type)
 461
 462     def testCopyWrongArg(self):
 463         acl = ACL()
 464         e = acl.append()
 465         self.assertRaises(TypeError, e.copy, object())
 466
 467     def testSetPermset(self):
 468         acl = ACL()
 469         e1 = acl.append()
 470         e1.tag_type = ACL_USER
 471         p1 = e1.permset
 472         p1.clear()
 473         p1.read = True
 474         p1.write = True
 475         e2 = acl.append()
 476         e2.tag_type = ACL_GROUP
 477         p2 = e2.permset
 478         p2.clear()
 479         p2.read = True
 480         self.assertFalse(p2.write)
 481         e2.permset = p1
 482         self.assertTrue(e2.permset.write)
 483         self.assertEqual(e2.tag_type, ACL_GROUP)
 484
 485     def testSetPermsetWrongArg(self):
 486         acl = ACL()
 487         e = acl.append()
 488         def setter(v):
 489             e.permset = v
 490         self.assertRaises(TypeError, setter, object())
 491
 492     def testPermsetCreation(self):
 493         acl = ACL()
 494         e = acl.append()
 495         p1 = e.permset
 496         p2 = Permset(e)
 497         #self.assertEqual(p1, p2)
 498
 499     def testPermsetCreationWrongArg(self):
 500         self.assertRaises(TypeError, Permset, object())
 501
 502     def testPermset(self):
 503         """Test permissions"""
 504         acl = posix1e.ACL()
 505         e = acl.append()
 506         ps = e.permset
 507         ps.clear()
 508         str_ps = str(ps)
 509         self.checkRef(str_ps)
 510         for perm in PERMSETS:
 511             str_ps = str(ps)
 512             txt = PERMSETS[perm][0]
 513             self.checkRef(str_ps)
 514             self.assertFalse(ps.test(perm), "Empty permission set should not"
 515                 " have permission '%s'" % txt)
 516             ps.add(perm)
 517             self.assertTrue(ps.test(perm), "Permission '%s' should exist"
 518                 " after addition" % txt)
 519             str_ps = str(ps)
 520             self.checkRef(str_ps)
 521             ps.delete(perm)
 522             self.assertFalse(ps.test(perm), "Permission '%s' should not exist"
 523                 " after deletion" % txt)
 524
 525     def testPermsetViaAccessors(self):
 526         """Test permissions"""
 527         acl = posix1e.ACL()
 528         e = acl.append()
 529         ps = e.permset
 530         ps.clear()
 531         str_ps = str(ps)
 532         self.checkRef(str_ps)
 533         def getter(perm):
 534             return PERMSETS[perm][1].__get__(ps)
 535         def setter(parm, value):
 536             return PERMSETS[perm][1].__set__(ps, value)
 537         for perm in PERMSETS:
 538             str_ps = str(ps)
 539             self.checkRef(str_ps)
 540             txt = PERMSETS[perm][0]
 541             self.assertFalse(getter(perm), "Empty permission set should not"
 542                 " have permission '%s'" % txt)
 543             setter(perm, True)
 544             self.assertTrue(ps.test(perm), "Permission '%s' should exist"
 545                 " after addition" % txt)
 546             self.assertTrue(getter(perm), "Permission '%s' should exist"
 547                 " after addition" % txt)
 548             str_ps = str(ps)
 549             self.checkRef(str_ps)
 550             setter(perm, False)
 551             self.assertFalse(ps.test(perm), "Permission '%s' should not exist"
 552                 " after deletion" % txt)
 553             self.assertFalse(getter(perm), "Permission '%s' should not exist"
 554                 " after deletion" % txt)
 555
 556     def testPermsetInvalidType(self):
 557         acl = posix1e.ACL()
 558         e = acl.append()
 559         ps = e.permset
 560         ps.clear()
 561         def setter():
 562             ps.write = object()
 563         self.assertRaises(TypeError, ps.add, "foobar")
 564         self.assertRaises(TypeError, ps.delete, "foobar")
 565         self.assertRaises(TypeError, ps.test, "foobar")
 566         self.assertRaises(ValueError, setter)
 567
 568     @unittest.skipUnless(IS_PY_3K, "Only supported under Python 3")
 569     def testQualifierValues(self):
 570         """Tests qualifier correct store/retrieval"""
 571         acl = posix1e.ACL()
 572         e = acl.append()
 573         # work around deprecation warnings
 574         if hasattr(self, 'assertRegex'):
 575             fn = self.assertRegex
 576         else:
 577             fn = self.assertRegexpMatches
 578         for tag in [posix1e.ACL_USER, posix1e.ACL_GROUP]:
 579             qualifier = 1
 580             e.tag_type = tag
 581             while True:
 582                 if tag == posix1e.ACL_USER:
 583                     regex = re.compile("user with uid %d" % qualifier)
 584                 else:
 585                     regex = re.compile("group with gid %d" % qualifier)
 586                 try:
 587                     e.qualifier = qualifier
 588                 except OverflowError:
 589                     # reached overflow condition, break
 590                     break
 591                 self.assertEqual(e.qualifier, qualifier)
 592                 fn(str(e), regex)
 593                 qualifier *= 2
 594
 595     @unittest.skipUnless(IS_PY_3K, "Only supported under Python 3")
 596     def testQualifierOverflow(self):
 597         """Tests qualifier overflow handling"""
 598         acl = posix1e.ACL()
 599         e = acl.append()
 600         qualifier = sys.maxsize * 2
 601         for tag in [posix1e.ACL_USER, posix1e.ACL_GROUP]:
 602             e.tag_type = tag
 603             with self.assertRaises(OverflowError):
 604                 e.qualifier = qualifier
 605
 606     @unittest.skipUnless(IS_PY_3K, "Only supported under Python 3")
 607     def testNegativeQualifier(self):
 608         """Tests negative qualifier handling"""
 609         # Note: this presumes that uid_t/gid_t in C are unsigned...
 610         acl = posix1e.ACL()
 611         e = acl.append()
 612         for tag in [posix1e.ACL_USER, posix1e.ACL_GROUP]:
 613             e.tag_type = tag
 614             for qualifier in [-10, -5, -1]:
 615                 with self.assertRaises(OverflowError):
 616                     e.qualifier = qualifier
 617
 618     def testInvalidQualifier(self):
 619         """Tests invalid qualifier handling"""
 620         acl = posix1e.ACL()
 621         e = acl.append()
 622         def set_qual(x):
 623             e.qualifier = x
 624         def del_qual():
 625             del e.qualifier
 626         self.assertRaises(TypeError, set_qual, object())
 627         self.assertRaises((TypeError, AttributeError), del_qual)
 628
 629     def testQualifierOnWrongTag(self):
 630         """Tests qualifier setting on wrong tag"""
 631         acl = posix1e.ACL()
 632         e = acl.append()
 633         e.tag_type = posix1e.ACL_OTHER
 634         def set_qual(x):
 635             e.qualifier = x
 636         def get_qual():
 637             return e.qualifier
 638         self.assertRaises(TypeError, set_qual, 1)
 639         self.assertRaises(TypeError, get_qual)
 640
 641
 642     def testTagTypes(self):
 643         """Tests tag type correct set/get"""
 644         acl = posix1e.ACL()
 645         e = acl.append()
 646         for tag in [posix1e.ACL_USER, posix1e.ACL_GROUP, posix1e.ACL_USER_OBJ,
 647                     posix1e.ACL_GROUP_OBJ, posix1e.ACL_MASK,
 648                     posix1e.ACL_OTHER]:
 649             e.tag_type = tag
 650             self.assertEqual(e.tag_type, tag)
 651             # check we can show all tag types without breaking
 652             self.assertTrue(str(e))
 653
 654     def testInvalidTags(self):
 655         """Tests tag type incorrect set/get"""
 656         acl = posix1e.ACL()
 657         e = acl.append()
 658         def set_tag(x):
 659           e.tag_type = x
 660         self.assertRaises(TypeError, set_tag, object())
 661         def delete_tag():
 662           del e.tag_type
 663         # For some reason, PyPy raises AttributeError. Strange...
 664         self.assertRaises((TypeError, AttributeError), delete_tag)
 665
 666         e.tag_type = posix1e.ACL_USER_OBJ
 667         tag = max([posix1e.ACL_USER, posix1e.ACL_GROUP, posix1e.ACL_USER_OBJ,
 668                    posix1e.ACL_GROUP_OBJ, posix1e.ACL_MASK,
 669                    posix1e.ACL_OTHER]) + 1
 670         self.assertRaises(EnvironmentError, set_tag, tag)
 671         # Check tag is still valid.
 672         self.assertEqual(e.tag_type, posix1e.ACL_USER_OBJ)
 673
 674 if __name__ == "__main__":
 675     unittest.main()