Port test_pwd.py to PyUnit. Check that getpwall() and

getpwnam()/getpwuid() return consistent data.

Change test_grp to check that getgrall() and
getgrnam()/getgrgid() return consistent data.
Add error checks similar to test_pwd.py.

Port test___all__.py to PyUnit.

From SF patch #662807.

Lib/test/test_pwd.py

@@ -1,71 +1,82 @@
-from test.test_support import verbose
+import unittest
+from test import test_support
+
 import pwd
 
-print 'pwd.getpwall()'
-entries = pwd.getpwall()
+class PwdTest(unittest.TestCase):
 
-for e in entries:
-    name = e[0]
-    uid = e[2]
-    if verbose:
-        print name, uid
-    print 'pwd.getpwuid()'
-    dbuid = pwd.getpwuid(uid)
-    if dbuid[0] != name:
-        print 'Mismatch in pwd.getpwuid()'
-    print 'pwd.getpwnam()'
-    dbname = pwd.getpwnam(name)
-    if dbname[2] != uid:
-        print 'Mismatch in pwd.getpwnam()'
-    else:
-        print 'name matches uid'
-    break
+    def test_values(self):
+        entries = pwd.getpwall()
 
-# try to get some errors
-bynames = {}
-byuids = {}
-for n, p, u, g, gecos, d, s in entries:
-    bynames[n] = u
-    byuids[u] = n
+        for e in entries:
+            self.assertEqual(len(e), 7)
+            self.assertEqual(e[0], e.pw_name)
+            self.assert_(isinstance(e.pw_name, basestring))
+            self.assertEqual(e[1], e.pw_passwd)
+            self.assert_(isinstance(e.pw_passwd, basestring))
+            self.assertEqual(e[2], e.pw_uid)
+            self.assert_(isinstance(e.pw_uid, int))
+            self.assertEqual(e[3], e.pw_gid)
+            self.assert_(isinstance(e.pw_gid, int))
+            self.assertEqual(e[4], e.pw_gecos)
+            self.assert_(isinstance(e.pw_gecos, basestring))
+            self.assertEqual(e[5], e.pw_dir)
+            self.assert_(isinstance(e.pw_dir, basestring))
+            self.assertEqual(e[6], e.pw_shell)
+            self.assert_(isinstance(e.pw_shell, basestring))
 
-allnames = bynames.keys()
-namei = 0
-fakename = allnames[namei]
-while bynames.has_key(fakename):
-    chars = map(None, fakename)
-    for i in range(len(chars)):
-        if chars[i] == 'z':
-            chars[i] = 'A'
-            break
-        elif chars[i] == 'Z':
-            continue
-        else:
-            chars[i] = chr(ord(chars[i]) + 1)
-            break
-    else:
-        namei = namei + 1
-        try:
-            fakename = allnames[namei]
-        except IndexError:
-            # should never happen... if so, just forget it
-            break
-    fakename = ''.join(map(None, chars))
+            self.assertEqual(pwd.getpwnam(e.pw_name), e)
+            self.assertEqual(pwd.getpwuid(e.pw_uid), e)
 
-try:
-    pwd.getpwnam(fakename)
-except KeyError:
-    print 'caught expected exception'
-else:
-    print 'fakename', fakename, 'did not except pwd.getpwnam()'
+    def test_errors(self):
+        self.assertRaises(TypeError, pwd.getpwuid)
+        self.assertRaises(TypeError, pwd.getpwnam)
+        self.assertRaises(TypeError, pwd.getpwall, 42)
 
-# Choose a non-existent uid.
-fakeuid = 4127
-while byuids.has_key(fakeuid):
-    fakeuid = (fakeuid * 3) % 0x10000
+        # try to get some errors
+        bynames = {}
+        byuids = {}
+        for (n, p, u, g, gecos, d, s) in pwd.getpwall():
+            bynames[n] = u
+            byuids[u] = n
+
+        allnames = bynames.keys()
+        namei = 0
+        fakename = allnames[namei]
+        while fakename in bynames:
+            chars = map(None, fakename)
+            for i in xrange(len(chars)):
+                if chars[i] == 'z':
+                    chars[i] = 'A'
+                    break
+                elif chars[i] == 'Z':
+                    continue
+                else:
+                    chars[i] = chr(ord(chars[i]) + 1)
+                    break
+            else:
+                namei = namei + 1
+                try:
+                    fakename = allnames[namei]
+                except IndexError:
+                    # should never happen... if so, just forget it
+                    break
+            fakename = ''.join(map(None, chars))
+
+        self.assertRaises(KeyError, pwd.getpwnam, fakename)
+
+        # Choose a non-existent uid.
+        fakeuid = 4127
+        while fakeuid in byuids:
+            fakeuid = (fakeuid * 3) % 0x10000
+
+        self.assertRaises(KeyError, pwd.getpwuid, fakeuid)
+
+def test_main():
+    suite = unittest.TestSuite()
+    suite.addTest(unittest.makeSuite(PwdTest))
+    test_support.run_suite(suite)
+
+if __name__ == "__main__":
+    test_main()
 
-try:
-    pwd.getpwuid(fakeuid)
-except KeyError:
-    print 'caught expected exception'
-else:
-    print 'fakeuid', fakeuid, 'did not except pwd.getpwuid()'