Copy in the rest of CPython's lib/test dir

CMakeLists.txt

@@ -336,4 +336,4 @@ else()
 endif()
 
 # last file added (need to change this if we add a file that is added via a glob):
-# from_cpython/Lib/test/pickletester.py
+# from_cpython/Lib/test/test_zipimport.py

from_cpython/Lib/test/audiotests.py

+from test.test_support import findfile, TESTFN, unlink
+import unittest
+import array
+import io
+import pickle
+import sys
+import base64
+
+class UnseekableIO(file):
+    def tell(self):
+        raise io.UnsupportedOperation
+
+    def seek(self, *args, **kwargs):
+        raise io.UnsupportedOperation
+
+def fromhex(s):
+    return base64.b16decode(s.replace(' ', ''))
+
+def byteswap2(data):
+    a = array.array('h')
+    a.fromstring(data)
+    a.byteswap()
+    return a.tostring()
+
+def byteswap3(data):
+    ba = bytearray(data)
+    ba[::3] = data[2::3]
+    ba[2::3] = data[::3]
+    return bytes(ba)
+
+def byteswap4(data):
+    a = array.array('i')
+    a.fromstring(data)
+    a.byteswap()
+    return a.tostring()
+
+
+class AudioTests:
+    close_fd = False
+
+    def setUp(self):
+        self.f = self.fout = None
+
+    def tearDown(self):
+        if self.f is not None:
+            self.f.close()
+        if self.fout is not None:
+            self.fout.close()
+        unlink(TESTFN)
+
+    def check_params(self, f, nchannels, sampwidth, framerate, nframes,
+                     comptype, compname):
+        self.assertEqual(f.getnchannels(), nchannels)
+        self.assertEqual(f.getsampwidth(), sampwidth)
+        self.assertEqual(f.getframerate(), framerate)
+        self.assertEqual(f.getnframes(), nframes)
+        self.assertEqual(f.getcomptype(), comptype)
+        self.assertEqual(f.getcompname(), compname)
+
+        params = f.getparams()
+        self.assertEqual(params,
+                (nchannels, sampwidth, framerate, nframes, comptype, compname))
+
+        dump = pickle.dumps(params)
+        self.assertEqual(pickle.loads(dump), params)
+
+
+class AudioWriteTests(AudioTests):
+
+    def create_file(self, testfile):
+        f = self.fout = self.module.open(testfile, 'wb')
+        f.setnchannels(self.nchannels)
+        f.setsampwidth(self.sampwidth)
+        f.setframerate(self.framerate)
+        f.setcomptype(self.comptype, self.compname)
+        return f
+
+    def check_file(self, testfile, nframes, frames):
+        f = self.module.open(testfile, 'rb')
+        try:
+            self.assertEqual(f.getnchannels(), self.nchannels)
+            self.assertEqual(f.getsampwidth(), self.sampwidth)
+            self.assertEqual(f.getframerate(), self.framerate)
+            self.assertEqual(f.getnframes(), nframes)
+            self.assertEqual(f.readframes(nframes), frames)
+        finally:
+            f.close()
+
+    def test_write_params(self):
+        f = self.create_file(TESTFN)
+        f.setnframes(self.nframes)
+        f.writeframes(self.frames)
+        self.check_params(f, self.nchannels, self.sampwidth, self.framerate,
+                          self.nframes, self.comptype, self.compname)
+        f.close()
+
+    def test_write(self):
+        f = self.create_file(TESTFN)
+        f.setnframes(self.nframes)
+        f.writeframes(self.frames)
+        f.close()
+
+        self.check_file(TESTFN, self.nframes, self.frames)
+
+    def test_incompleted_write(self):
+        with open(TESTFN, 'wb') as testfile:
+            testfile.write(b'ababagalamaga')
+            f = self.create_file(testfile)
+            f.setnframes(self.nframes + 1)
+            f.writeframes(self.frames)
+            f.close()
+
+        with open(TESTFN, 'rb') as testfile:
+            self.assertEqual(testfile.read(13), b'ababagalamaga')
+            self.check_file(testfile, self.nframes, self.frames)
+
+    def test_multiple_writes(self):
+        with open(TESTFN, 'wb') as testfile:
+            testfile.write(b'ababagalamaga')
+            f = self.create_file(testfile)
+            f.setnframes(self.nframes)
+            framesize = self.nchannels * self.sampwidth
+            f.writeframes(self.frames[:-framesize])
+            f.writeframes(self.frames[-framesize:])
+            f.close()
+
+        with open(TESTFN, 'rb') as testfile:
+            self.assertEqual(testfile.read(13), b'ababagalamaga')
+            self.check_file(testfile, self.nframes, self.frames)
+
+    def test_overflowed_write(self):
+        with open(TESTFN, 'wb') as testfile:
+            testfile.write(b'ababagalamaga')
+            f = self.create_file(testfile)
+            f.setnframes(self.nframes - 1)
+            f.writeframes(self.frames)
+            f.close()
+
+        with open(TESTFN, 'rb') as testfile:
+            self.assertEqual(testfile.read(13), b'ababagalamaga')
+            self.check_file(testfile, self.nframes, self.frames)
+
+    def test_unseekable_read(self):
+        f = self.create_file(TESTFN)
+        f.setnframes(self.nframes)
+        f.writeframes(self.frames)
+        f.close()
+
+        with UnseekableIO(TESTFN, 'rb') as testfile:
+            self.check_file(testfile, self.nframes, self.frames)
+
+    def test_unseekable_write(self):
+        with UnseekableIO(TESTFN, 'wb') as testfile:
+            f = self.create_file(testfile)
+            f.setnframes(self.nframes)
+            f.writeframes(self.frames)
+            f.close()
+            self.fout = None
+
+        self.check_file(TESTFN, self.nframes, self.frames)
+
+    def test_unseekable_incompleted_write(self):
+        with UnseekableIO(TESTFN, 'wb') as testfile:
+            testfile.write(b'ababagalamaga')
+            f = self.create_file(testfile)
+            f.setnframes(self.nframes + 1)
+            try:
+                f.writeframes(self.frames)
+            except IOError:
+                pass
+            try:
+                f.close()
+            except IOError:
+                pass
+
+        with open(TESTFN, 'rb') as testfile:
+            self.assertEqual(testfile.read(13), b'ababagalamaga')
+            self.check_file(testfile, self.nframes + 1, self.frames)
+
+    def test_unseekable_overflowed_write(self):
+        with UnseekableIO(TESTFN, 'wb') as testfile:
+            testfile.write(b'ababagalamaga')
+            f = self.create_file(testfile)
+            f.setnframes(self.nframes - 1)
+            try:
+                f.writeframes(self.frames)
+            except IOError:
+                pass
+            try:
+                f.close()
+            except IOError:
+                pass
+
+        with open(TESTFN, 'rb') as testfile:
+            self.assertEqual(testfile.read(13), b'ababagalamaga')
+            framesize = self.nchannels * self.sampwidth
+            self.check_file(testfile, self.nframes - 1, self.frames[:-framesize])
+
+
+class AudioTestsWithSourceFile(AudioTests):
+
+    @classmethod
+    def setUpClass(cls):
+        cls.sndfilepath = findfile(cls.sndfilename, subdir='audiodata')
+
+    def test_read_params(self):
+        f = self.f = self.module.open(self.sndfilepath)
+        #self.assertEqual(f.getfp().name, self.sndfilepath)
+        self.check_params(f, self.nchannels, self.sampwidth, self.framerate,
+                          self.sndfilenframes, self.comptype, self.compname)
+
+    def test_close(self):
+        with open(self.sndfilepath, 'rb') as testfile:
+            f = self.f = self.module.open(testfile)
+            self.assertFalse(testfile.closed)
+            f.close()
+            self.assertEqual(testfile.closed, self.close_fd)
+        with open(TESTFN, 'wb') as testfile:
+            fout = self.fout = self.module.open(testfile, 'wb')
+            self.assertFalse(testfile.closed)
+            with self.assertRaises(self.module.Error):
+                fout.close()
+            self.assertEqual(testfile.closed, self.close_fd)
+            fout.close() # do nothing
+
+    def test_read(self):
+        framesize = self.nchannels * self.sampwidth
+        chunk1 = self.frames[:2 * framesize]
+        chunk2 = self.frames[2 * framesize: 4 * framesize]
+        f = self.f = self.module.open(self.sndfilepath)
+        self.assertEqual(f.readframes(0), b'')
+        self.assertEqual(f.tell(), 0)
+        self.assertEqual(f.readframes(2), chunk1)
+        f.rewind()
+        pos0 = f.tell()
+        self.assertEqual(pos0, 0)
+        self.assertEqual(f.readframes(2), chunk1)
+        pos2 = f.tell()
+        self.assertEqual(pos2, 2)
+        self.assertEqual(f.readframes(2), chunk2)
+        f.setpos(pos2)
+        self.assertEqual(f.readframes(2), chunk2)
+        f.setpos(pos0)
+        self.assertEqual(f.readframes(2), chunk1)
+        with self.assertRaises(self.module.Error):
+            f.setpos(-1)
+        with self.assertRaises(self.module.Error):
+            f.setpos(f.getnframes() + 1)
+
+    def test_copy(self):
+        f = self.f = self.module.open(self.sndfilepath)
+        fout = self.fout = self.module.open(TESTFN, 'wb')
+        fout.setparams(f.getparams())
+        i = 0
+        n = f.getnframes()
+        while n > 0:
+            i += 1
+            fout.writeframes(f.readframes(i))
+            n -= i
+        fout.close()
+        fout = self.fout = self.module.open(TESTFN, 'rb')
+        f.rewind()
+        self.assertEqual(f.getparams(), fout.getparams())
+        self.assertEqual(f.readframes(f.getnframes()),
+                         fout.readframes(fout.getnframes()))
+
+    def test_read_not_from_start(self):
+        with open(TESTFN, 'wb') as testfile:
+            testfile.write(b'ababagalamaga')
+            with open(self.sndfilepath, 'rb') as f:
+                testfile.write(f.read())
+
+        with open(TESTFN, 'rb') as testfile:
+            self.assertEqual(testfile.read(13), b'ababagalamaga')
+            f = self.module.open(testfile, 'rb')
+            try:
+                self.assertEqual(f.getnchannels(), self.nchannels)
+                self.assertEqual(f.getsampwidth(), self.sampwidth)
+                self.assertEqual(f.getframerate(), self.framerate)
+                self.assertEqual(f.getnframes(), self.sndfilenframes)
+                self.assertEqual(f.readframes(self.nframes), self.frames)
+            finally:
+                f.close()

from_cpython/Lib/test/autotest.py

+# This should be equivalent to running regrtest.py from the cmdline.
+# It can be especially handy if you're in an interactive shell, e.g.,
+# from test import autotest.
+
+from test import regrtest
+regrtest.main()

from_cpython/Lib/test/bad_coding.py

+# -*- coding: uft-8 -*-

from_cpython/Lib/test/bad_coding2.py

+#coding: utf8
+print '我'

from_cpython/Lib/test/bad_coding3.py

+# coding: string-escape
+\x70\x72\x69\x6e\x74\x20\x32\x2b\x32\x0a

from_cpython/Lib/test/badcert.pem

+-----BEGIN RSA PRIVATE KEY-----
+MIICXwIBAAKBgQC8ddrhm+LutBvjYcQlnH21PPIseJ1JVG2HMmN2CmZk2YukO+9L
+opdJhTvbGfEj0DQs1IE8M+kTUyOmuKfVrFMKwtVeCJphrAnhoz7TYOuLBSqt7lVH
+fhi/VwovESJlaBOp+WMnfhcduPEYHYx/6cnVapIkZnLt30zu2um+DzA9jQIDAQAB
+AoGBAK0FZpaKj6WnJZN0RqhhK+ggtBWwBnc0U/ozgKz2j1s3fsShYeiGtW6CK5nU
+D1dZ5wzhbGThI7LiOXDvRucc9n7vUgi0alqPQ/PFodPxAN/eEYkmXQ7W2k7zwsDA
+IUK0KUhktQbLu8qF/m8qM86ba9y9/9YkXuQbZ3COl5ahTZrhAkEA301P08RKv3KM
+oXnGU2UHTuJ1MAD2hOrPxjD4/wxA/39EWG9bZczbJyggB4RHu0I3NOSFjAm3HQm0
+ANOu5QK9owJBANgOeLfNNcF4pp+UikRFqxk5hULqRAWzVxVrWe85FlPm0VVmHbb/
+loif7mqjU8o1jTd/LM7RD9f2usZyE2psaw8CQQCNLhkpX3KO5kKJmS9N7JMZSc4j
+oog58yeYO8BBqKKzpug0LXuQultYv2K4veaIO04iL9VLe5z9S/Q1jaCHBBuXAkEA
+z8gjGoi1AOp6PBBLZNsncCvcV/0aC+1se4HxTNo2+duKSDnbq+ljqOM+E7odU+Nq
+ewvIWOG//e8fssd0mq3HywJBAJ8l/c8GVmrpFTx8r/nZ2Pyyjt3dH1widooDXYSV
+q6Gbf41Llo5sYAtmxdndTLASuHKecacTgZVhy0FryZpLKrU=
+-----END RSA PRIVATE KEY-----
+-----BEGIN CERTIFICATE-----
+Just bad cert data
+-----END CERTIFICATE-----
+-----BEGIN RSA PRIVATE KEY-----
+MIICXwIBAAKBgQC8ddrhm+LutBvjYcQlnH21PPIseJ1JVG2HMmN2CmZk2YukO+9L
+opdJhTvbGfEj0DQs1IE8M+kTUyOmuKfVrFMKwtVeCJphrAnhoz7TYOuLBSqt7lVH
+fhi/VwovESJlaBOp+WMnfhcduPEYHYx/6cnVapIkZnLt30zu2um+DzA9jQIDAQAB
+AoGBAK0FZpaKj6WnJZN0RqhhK+ggtBWwBnc0U/ozgKz2j1s3fsShYeiGtW6CK5nU
+D1dZ5wzhbGThI7LiOXDvRucc9n7vUgi0alqPQ/PFodPxAN/eEYkmXQ7W2k7zwsDA
+IUK0KUhktQbLu8qF/m8qM86ba9y9/9YkXuQbZ3COl5ahTZrhAkEA301P08RKv3KM
+oXnGU2UHTuJ1MAD2hOrPxjD4/wxA/39EWG9bZczbJyggB4RHu0I3NOSFjAm3HQm0
+ANOu5QK9owJBANgOeLfNNcF4pp+UikRFqxk5hULqRAWzVxVrWe85FlPm0VVmHbb/
+loif7mqjU8o1jTd/LM7RD9f2usZyE2psaw8CQQCNLhkpX3KO5kKJmS9N7JMZSc4j
+oog58yeYO8BBqKKzpug0LXuQultYv2K4veaIO04iL9VLe5z9S/Q1jaCHBBuXAkEA
+z8gjGoi1AOp6PBBLZNsncCvcV/0aC+1se4HxTNo2+duKSDnbq+ljqOM+E7odU+Nq
+ewvIWOG//e8fssd0mq3HywJBAJ8l/c8GVmrpFTx8r/nZ2Pyyjt3dH1widooDXYSV
+q6Gbf41Llo5sYAtmxdndTLASuHKecacTgZVhy0FryZpLKrU=
+-----END RSA PRIVATE KEY-----
+-----BEGIN CERTIFICATE-----
+Just bad cert data
+-----END CERTIFICATE-----

from_cpython/Lib/test/badkey.pem

+-----BEGIN RSA PRIVATE KEY-----
+Bad Key, though the cert should be OK
+-----END RSA PRIVATE KEY-----
+-----BEGIN CERTIFICATE-----
+MIICpzCCAhCgAwIBAgIJAP+qStv1cIGNMA0GCSqGSIb3DQEBBQUAMIGJMQswCQYD
+VQQGEwJVUzERMA8GA1UECBMIRGVsYXdhcmUxEzARBgNVBAcTCldpbG1pbmd0b24x
+IzAhBgNVBAoTGlB5dGhvbiBTb2Z0d2FyZSBGb3VuZGF0aW9uMQwwCgYDVQQLEwNT
+U0wxHzAdBgNVBAMTFnNvbWVtYWNoaW5lLnB5dGhvbi5vcmcwHhcNMDcwODI3MTY1
+NDUwWhcNMTMwMjE2MTY1NDUwWjCBiTELMAkGA1UEBhMCVVMxETAPBgNVBAgTCERl
+bGF3YXJlMRMwEQYDVQQHEwpXaWxtaW5ndG9uMSMwIQYDVQQKExpQeXRob24gU29m
+dHdhcmUgRm91bmRhdGlvbjEMMAoGA1UECxMDU1NMMR8wHQYDVQQDExZzb21lbWFj
+aGluZS5weXRob24ub3JnMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC8ddrh
+m+LutBvjYcQlnH21PPIseJ1JVG2HMmN2CmZk2YukO+9LopdJhTvbGfEj0DQs1IE8
+M+kTUyOmuKfVrFMKwtVeCJphrAnhoz7TYOuLBSqt7lVHfhi/VwovESJlaBOp+WMn
+fhcduPEYHYx/6cnVapIkZnLt30zu2um+DzA9jQIDAQABoxUwEzARBglghkgBhvhC
+AQEEBAMCBkAwDQYJKoZIhvcNAQEFBQADgYEAF4Q5BVqmCOLv1n8je/Jw9K669VXb
+08hyGzQhkemEBYQd6fzQ9A/1ZzHkJKb1P6yreOLSEh4KcxYPyrLRC1ll8nr5OlCx
+CMhKkTnR6qBsdNV0XtdU2+N25hqW+Ma4ZeqsN/iiJVCGNOZGnvQuvCAGWF8+J/f/
+iHkC6gGdBJhogs4=
+-----END CERTIFICATE-----
+-----BEGIN RSA PRIVATE KEY-----
+Bad Key, though the cert should be OK
+-----END RSA PRIVATE KEY-----
+-----BEGIN CERTIFICATE-----
+MIICpzCCAhCgAwIBAgIJAP+qStv1cIGNMA0GCSqGSIb3DQEBBQUAMIGJMQswCQYD
+VQQGEwJVUzERMA8GA1UECBMIRGVsYXdhcmUxEzARBgNVBAcTCldpbG1pbmd0b24x
+IzAhBgNVBAoTGlB5dGhvbiBTb2Z0d2FyZSBGb3VuZGF0aW9uMQwwCgYDVQQLEwNT
+U0wxHzAdBgNVBAMTFnNvbWVtYWNoaW5lLnB5dGhvbi5vcmcwHhcNMDcwODI3MTY1
+NDUwWhcNMTMwMjE2MTY1NDUwWjCBiTELMAkGA1UEBhMCVVMxETAPBgNVBAgTCERl
+bGF3YXJlMRMwEQYDVQQHEwpXaWxtaW5ndG9uMSMwIQYDVQQKExpQeXRob24gU29m
+dHdhcmUgRm91bmRhdGlvbjEMMAoGA1UECxMDU1NMMR8wHQYDVQQDExZzb21lbWFj
+aGluZS5weXRob24ub3JnMIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQC8ddrh
+m+LutBvjYcQlnH21PPIseJ1JVG2HMmN2CmZk2YukO+9LopdJhTvbGfEj0DQs1IE8
+M+kTUyOmuKfVrFMKwtVeCJphrAnhoz7TYOuLBSqt7lVHfhi/VwovESJlaBOp+WMn
+fhcduPEYHYx/6cnVapIkZnLt30zu2um+DzA9jQIDAQABoxUwEzARBglghkgBhvhC
+AQEEBAMCBkAwDQYJKoZIhvcNAQEFBQADgYEAF4Q5BVqmCOLv1n8je/Jw9K669VXb
+08hyGzQhkemEBYQd6fzQ9A/1ZzHkJKb1P6yreOLSEh4KcxYPyrLRC1ll8nr5OlCx
+CMhKkTnR6qBsdNV0XtdU2+N25hqW+Ma4ZeqsN/iiJVCGNOZGnvQuvCAGWF8+J/f/
+iHkC6gGdBJhogs4=
+-----END CERTIFICATE-----

from_cpython/Lib/test/badsyntax_future3.py

+"""This is a test"""
+from __future__ import nested_scopes
+from __future__ import rested_snopes
+
+def f(x):
+    def g(y):
+        return x + y
+    return g
+
+result = f(2)(4)

from_cpython/Lib/test/badsyntax_future4.py

+"""This is a test"""
+import __future__
+from __future__ import nested_scopes
+
+def f(x):
+    def g(y):
+        return x + y
+    return g
+
+result = f(2)(4)

from_cpython/Lib/test/badsyntax_future5.py

+"""This is a test"""
+from __future__ import nested_scopes
+import foo
+from __future__ import nested_scopes
+
+
+def f(x):
+    def g(y):
+        return x + y
+    return g
+
+result = f(2)(4)

from_cpython/Lib/test/badsyntax_future6.py

+"""This is a test"""
+"this isn't a doc string"
+from __future__ import nested_scopes
+
+def f(x):
+    def g(y):
+        return x + y
+    return g
+
+result = f(2)(4)

from_cpython/Lib/test/badsyntax_future7.py

+"""This is a test"""
+
+from __future__ import nested_scopes; import string; from __future__ import \
+     nested_scopes
+
+def f(x):
+    def g(y):
+        return x + y
+    return g
+
+result = f(2)(4)

from_cpython/Lib/test/badsyntax_future8.py

+"""This is a test"""
+
+from __future__ import *
+
+def f(x):
+    def g(y):
+        return x + y
+    return g
+
+print f(2)(4)

from_cpython/Lib/test/badsyntax_future9.py

+"""This is a test"""
+
+from __future__ import nested_scopes, braces
+
+def f(x):
+    def g(y):
+        return x + y
+    return g
+
+print f(2)(4)

from_cpython/Lib/test/badsyntax_nocaret.py

+def f(x):
+    [x for x in x] = x

from_cpython/Lib/test/cfgparser.1

+[Foo Bar]
+foo=newbar

from_cpython/Lib/test/check_soundcard.vbs

+rem Check for a working sound-card - exit with 0 if OK, 1 otherwise.
+set wmi = GetObject("winmgmts:")
+set scs = wmi.InstancesOf("win32_sounddevice")
+for each sc in scs
+   set status = sc.Properties_("Status")
+   wscript.Echo(sc.Properties_("Name") + "/" + status)
+   if status = "OK" then
+       wscript.Quit 0 rem normal exit
+   end if
+next
+rem No sound card found - exit with status code of 1
+wscript.Quit 1
+

from_cpython/Lib/test/cjkencodings/big5-utf8.txt

+如何在 Python 中使用既有的 C library?
+　在資訊科技快速發展的今天, 開發及測試軟體的速度是不容忽視的
+課題. 為加快開發及測試的速度, 我們便常希望能利用一些已開發好的
+library, 並有一個 fast prototyping 的 programming language 可
+供使用. 目前有許許多多的 library 是以 C 寫成, 而 Python 是一個
+fast prototyping 的 programming language. 故我們希望能將既有的
+C library 拿到 Python 的環境中測試及整合. 其中最主要也是我們所
+要討論的問題就是:
+

from_cpython/Lib/test/cjkencodings/big5.txt

+如何在 Python 中使用既有的 C library?
+　在資訊科技快速發展的今天, 開發及測試軟體的速度是不容忽視的
+課題. 為加快開發及測試的速度, 我們便常希望能利用一些已開發好的
+library, 並有一個 fast prototyping 的 programming language 可
+供使用. 目前有許許多多的 library 是以 C 寫成, 而 Python 是一個
+fast prototyping 的 programming language. 故我們希望能將既有的
+C library 拿到 Python 的環境中測試及整合. 其中最主要也是我們所
+要討論的問題就是:
+

from_cpython/Lib/test/cjkencodings/big5hkscs-utf8.txt

+𠄌Ě鵮罓洆
+ÊÊ̄ê êê̄

from_cpython/Lib/test/cjkencodings/big5hkscs.txt

+E\sڍ
+fb 

from_cpython/Lib/test/cjkencodings/cp949-utf8.txt

+똠방각하 펲시콜라
+
+㉯㉯납!! 因九月패믤릔궈 ⓡⓖ훀¿¿¿ 긍뒙 ⓔ뎨 ㉯. .
+亞영ⓔ능횹 . . . . 서울뤄 뎐학乙 家훀 ! ! !ㅠ.ㅠ
+흐흐흐 ㄱㄱㄱ☆ㅠ_ㅠ 어릨 탸콰긐 뎌응 칑九들乙 ㉯드긐
+설릌 家훀 . . . . 굴애쉌 ⓔ궈 ⓡ릘㉱긐 因仁川女中까즼
+와쒀훀 ! ! 亞영ⓔ 家능궈 ☆上관 없능궈능 亞능뒈훀 글애듴
+ⓡ려듀九 싀풔숴훀 어릨 因仁川女中싁⑨들앜!! ㉯㉯납♡ ⌒⌒*
+

from_cpython/Lib/test/cjkencodings/cp949.txt

+寞陝 藥搋
+
+阱阱陶!! 孻朐篘掬 佺來麗０００ 晤 供絨 阱. .
+銢艙供棟 . . . . 憮選瘀 粟錟 坅麗 ! ! !壬.壬
+ 丑丑丑≧壬_壬 橫 攣攜 筑擬 疲朐菟錟 阱萄
+撲 坅麗 . . . . 掉擁 供掬 佺阬 孻嬬藿澇齌梱
+諦冀麗 ! ! 銢艙供 坅棟掬 ≧葞婦 橈棟掬棟 銢棟華麗 旋擁
+佺溥菽朐 膜麗 橫 孻嬬藿澇齌剁菟!! 阱阱陶Ⅴ ÷÷*
+

from_cpython/Lib/test/cjkencodings/euc_jisx0213-utf8.txt

+Python の開発は、1990 年ごろから開始されています。
+開発者の Guido van Rossum は教育用のプログラミング言語「ABC」の開発に参加していましたが、ABC は実用上の目的にはあまり適していませんでした。
+このため、Guido はより実用的なプログラミング言語の開発を開始し、英国 BBS 放送のコメディ番組「モンティ パイソン」のファンである Guido はこの言語を「Python」と名づけました。
+このような背景から生まれた Python の言語設計は、「シンプル」で「習得が容易」という目標に重点が置かれています。
+多くのスクリプト系言語ではユーザの目先の利便性を優先して色々な機能を言語要素として取り入れる場合が多いのですが、Python ではそういった小細工が追加されることはあまりありません。
+言語自体の機能は最小限に押さえ、必要な機能は拡張モジュールとして追加する、というのが Python のポリシーです。
+
+ノか゚ ト゚ トキ喝塀 𡚴𪎌 麀齁𩛰

from_cpython/Lib/test/cjkencodings/euc_jisx0213.txt

+Python の開発は、1990 年ごろから開始されています。
+開発者の Guido van Rossum は教育用のプログラミング言語「ABC」の開発に参加していましたが、ABC は実用上の目的にはあまり適していませんでした。
+このため、Guido はより実用的なプログラミング言語の開発を開始し、英国 BBS 放送のコメディ番組「モンティ パイソン」のファンである Guido はこの言語を「Python」と名づけました。
+このような背景から生まれた Python の言語設計は、「シンプル」で「習得が容易」という目標に重点が置かれています。
+多くのスクリプト系言語ではユーザの目先の利便性を優先して色々な機能を言語要素として取り入れる場合が多いのですが、Python ではそういった小細工が追加されることはあまりありません。
+言語自体の機能は最小限に押さえ、必要な機能は拡張モジュールとして追加する、というのが Python のポリシーです。
+
+ノ  トキ  

from_cpython/Lib/test/cjkencodings/euc_jp-utf8.txt

+Python の開発は、1990 年ごろから開始されています。
+開発者の Guido van Rossum は教育用のプログラミング言語「ABC」の開発に参加していましたが、ABC は実用上の目的にはあまり適していませんでした。
+このため、Guido はより実用的なプログラミング言語の開発を開始し、英国 BBS 放送のコメディ番組「モンティ パイソン」のファンである Guido はこの言語を「Python」と名づけました。
+このような背景から生まれた Python の言語設計は、「シンプル」で「習得が容易」という目標に重点が置かれています。
+多くのスクリプト系言語ではユーザの目先の利便性を優先して色々な機能を言語要素として取り入れる場合が多いのですが、Python ではそういった小細工が追加されることはあまりありません。
+言語自体の機能は最小限に押さえ、必要な機能は拡張モジュールとして追加する、というのが Python のポリシーです。
+

from_cpython/Lib/test/cjkencodings/euc_jp.txt

+Python の開発は、1990 年ごろから開始されています。
+開発者の Guido van Rossum は教育用のプログラミング言語「ABC」の開発に参加していましたが、ABC は実用上の目的にはあまり適していませんでした。
+このため、Guido はより実用的なプログラミング言語の開発を開始し、英国 BBS 放送のコメディ番組「モンティ パイソン」のファンである Guido はこの言語を「Python」と名づけました。
+このような背景から生まれた Python の言語設計は、「シンプル」で「習得が容易」という目標に重点が置かれています。
+多くのスクリプト系言語ではユーザの目先の利便性を優先して色々な機能を言語要素として取り入れる場合が多いのですが、Python ではそういった小細工が追加されることはあまりありません。
+言語自体の機能は最小限に押さえ、必要な機能は拡張モジュールとして追加する、というのが Python のポリシーです。
+

from_cpython/Lib/test/cjkencodings/euc_kr-utf8.txt

+◎ 파이썬(Python)은 배우기 쉽고, 강력한 프로그래밍 언어입니다. 파이썬은
+효율적인 고수준 데이터 구조와 간단하지만 효율적인 객체지향프로그래밍을
+지원합니다. 파이썬의 우아(優雅)한 문법과 동적 타이핑, 그리고 인터프리팅
+환경은 파이썬을 스크립팅과 여러 분야에서와 대부분의 플랫폼에서의 빠른
+애플리케이션 개발을 할 수 있는 이상적인 언어로 만들어줍니다.
+
+☆첫가끝: 날아라 쓔쓔쓩~ 닁큼! 뜽금없이 전홥니다. 뷁. 그런거 읎다.

from_cpython/Lib/test/cjkencodings/euc_kr.txt

+◎ 파이썬(Python)은 배우기 쉽고, 강력한 프로그래밍 언어입니다. 파이썬은
+효율적인 고수준 데이터 구조와 간단하지만 효율적인 객체지향프로그래밍을
+지원합니다. 파이썬의 우아(優雅)한 문법과 동적 타이핑, 그리고 인터프리팅
+환경은 파이썬을 스크립팅과 여러 분야에서와 대부분의 플랫폼에서의 빠른
+애플리케이션 개발을 할 수 있는 이상적인 언어로 만들어줍니다.
+
+☆첫가끝: 날아라 ㅤㅆㅠㅤㅤㅆㅠㅤ쓩~ ㅤㄴㅢㅇ큼! ㅤㄸㅡㅇ금없이 전ㅤㅎㅘㅂ니다. ㅤㅂㅞㄺ. 그런거 ㅤㅇㅡㅄ다.

from_cpython/Lib/test/cjkencodings/gb18030-utf8.txt

+Python（派森）语言是一种功能强大而完善的通用型计算机程序设计语言，
+已经具有十多年的发展历史，成熟且稳定。这种语言具有非常简捷而清晰
+的语法特点，适合完成各种高层任务，几乎可以在所有的操作系统中
+运行。这种语言简单而强大，适合各种人士学习使用。目前，基于这
+种语言的相关技术正在飞速的发展，用户数量急剧扩大，相关的资源非常多。
+如何在 Python 中使用既有的 C library?
+　在資訊科技快速發展的今天, 開發及測試軟體的速度是不容忽視的
+課題. 為加快開發及測試的速度, 我們便常希望能利用一些已開發好的
+library, 並有一個 fast prototyping 的 programming language 可
+供使用. 目前有許許多多的 library 是以 C 寫成, 而 Python 是一個
+fast prototyping 的 programming language. 故我們希望能將既有的
+C library 拿到 Python 的環境中測試及整合. 其中最主要也是我們所
+要討論的問題就是:
+파이썬은 강력한 기능을 지닌 범용 컴퓨터 프로그래밍 언어다.
+

from_cpython/Lib/test/cjkencodings/gb18030.txt

+Python（派森）语言是一种功能强大而完善的通用型计算机程序设计语言，
+已经具有十多年的发展历史，成熟且稳定。这种语言具有非常简捷而清晰
+的语法特点，适合完成各种高层任务，几乎可以在所有的操作系统中
+运行。这种语言简单而强大，适合各种人士学习使用。目前，基于这
+种语言的相关技术正在飞速的发展，用户数量急剧扩大，相关的资源非常多。
+如何在 Python 中使用既有的 C library?
+　在資訊科技快速發展的今天, 開發及測試軟體的速度是不容忽視的
+課題. 為加快開發及測試的速度, 我們便常希望能利用一些已開發好的
+library, 並有一個 fast prototyping 的 programming language 可
+供使用. 目前有許許多多的 library 是以 C 寫成, 而 Python 是一個
+fast prototyping 的 programming language. 故我們希望能將既有的
+C library 拿到 Python 的環境中測試及整合. 其中最主要也是我們所
+要討論的問題就是:
+파이썬은 강력한 기능을 지닌 범용 컴퓨터 프로그래밍 언어다.
+

from_cpython/Lib/test/cjkencodings/gb2312-utf8.txt

+Python（派森）语言是一种功能强大而完善的通用型计算机程序设计语言，
+已经具有十多年的发展历史，成熟且稳定。这种语言具有非常简捷而清晰
+的语法特点，适合完成各种高层任务，几乎可以在所有的操作系统中
+运行。这种语言简单而强大，适合各种人士学习使用。目前，基于这
+种语言的相关技术正在飞速的发展，用户数量急剧扩大，相关的资源非常多。
+

from_cpython/Lib/test/cjkencodings/gb2312.txt

+Python（派森）语言是一种功能强大而完善的通用型计算机程序设计语言，
+已经具有十多年的发展历史，成熟且稳定。这种语言具有非常简捷而清晰
+的语法特点，适合完成各种高层任务，几乎可以在所有的操作系统中
+运行。这种语言简单而强大，适合各种人士学习使用。目前，基于这
+种语言的相关技术正在飞速的发展，用户数量急剧扩大，相关的资源非常多。
+

from_cpython/Lib/test/cjkencodings/gbk-utf8.txt

+Python（派森）语言是一种功能强大而完善的通用型计算机程序设计语言，
+已经具有十多年的发展历史，成熟且稳定。这种语言具有非常简捷而清晰
+的语法特点，适合完成各种高层任务，几乎可以在所有的操作系统中
+运行。这种语言简单而强大，适合各种人士学习使用。目前，基于这
+种语言的相关技术正在飞速的发展，用户数量急剧扩大，相关的资源非常多。
+如何在 Python 中使用既有的 C library?
+　在資訊科技快速發展的今天, 開發及測試軟體的速度是不容忽視的
+課題. 為加快開發及測試的速度, 我們便常希望能利用一些已開發好的
+library, 並有一個 fast prototyping 的 programming language 可
+供使用. 目前有許許多多的 library 是以 C 寫成, 而 Python 是一個
+fast prototyping 的 programming language. 故我們希望能將既有的
+C library 拿到 Python 的環境中測試及整合. 其中最主要也是我們所
+要討論的問題就是:
+

from_cpython/Lib/test/cjkencodings/gbk.txt

+Python（派森）语言是一种功能强大而完善的通用型计算机程序设计语言，
+已经具有十多年的发展历史，成熟且稳定。这种语言具有非常简捷而清晰
+的语法特点，适合完成各种高层任务，几乎可以在所有的操作系统中
+运行。这种语言简单而强大，适合各种人士学习使用。目前，基于这
+种语言的相关技术正在飞速的发展，用户数量急剧扩大，相关的资源非常多。
+如何在 Python 中使用既有的 C library?
+　在資訊科技快速發展的今天, 開發及測試軟體的速度是不容忽視的
+課題. 為加快開發及測試的速度, 我們便常希望能利用一些已開發好的
+library, 並有一個 fast prototyping 的 programming language 可
+供使用. 目前有許許多多的 library 是以 C 寫成, 而 Python 是一個
+fast prototyping 的 programming language. 故我們希望能將既有的
+C library 拿到 Python 的環境中測試及整合. 其中最主要也是我們所
+要討論的問題就是:
+

from_cpython/Lib/test/cjkencodings/hz-utf8.txt

+This sentence is in ASCII.
+The next sentence is in GB.己所不欲，勿施於人。Bye.

from_cpython/Lib/test/cjkencodings/hz.txt

+This sentence is in ASCII.
+The next sentence is in GB.~{<:Ky2;S{#,NpJ)l6HK!#~}Bye.

from_cpython/Lib/test/cjkencodings/iso2022_jp-utf8.txt

+Python の開発は、1990 年ごろから開始されています。
+開発者の Guido van Rossum は教育用のプログラミング言語「ABC」の開発に参加していましたが、ABC は実用上の目的にはあまり適していませんでした。
+このため、Guido はより実用的なプログラミング言語の開発を開始し、英国 BBS 放送のコメディ番組「モンティ パイソン」のファンである Guido はこの言語を「Python」と名づけました。
+このような背景から生まれた Python の言語設計は、「シンプル」で「習得が容易」という目標に重点が置かれています。
+多くのスクリプト系言語ではユーザの目先の利便性を優先して色々な機能を言語要素として取り入れる場合が多いのですが、Python ではそういった小細工が追加されることはあまりありません。
+言語自体の機能は最小限に押さえ、必要な機能は拡張モジュールとして追加する、というのが Python のポリシーです。
+

from_cpython/Lib/test/cjkencodings/iso2022_jp.txt

+Python $B$N3+H/$O!"(B1990 $BG/$4$m$+$i3+;O$5$l$F$$$^$9!#(B
+$B3+H/<T$N(B Guido van Rossum $B$O650iMQ$N%W%m%0%i%_%s%08@8l!V(BABC$B!W$N3+H/$K;22C$7$F$$$^$7$?$,!"(BABC $B$O<BMQ>e$NL\E*$K$O$"$^$jE,$7$F$$$^$;$s$G$7$?!#(B
+$B$3$N$?$a!"(BGuido $B$O$h$j<BMQE*$J%W%m%0%i%_%s%08@8l$N3+H/$r3+;O$7!"1Q9q(B BBS $BJ|Aw$N%3%a%G%#HVAH!V%b%s%F%#(B $B%Q%$%=%s!W$N%U%!%s$G$"$k(B Guido $B$O$3$N8@8l$r!V(BPython$B!W$HL>$E$1$^$7$?!#(B
+$B$3$N$h$&$JGX7J$+$i@8$^$l$?(B Python $B$N8@8l@_7W$O!"!V%7%s%W%k!W$G!V=,F@$,MF0W!W$H$$$&L\I8$K=EE@$,CV$+$l$F$$$^$9!#(B
+$BB?$/$N%9%/%j%W%H7O8@8l$G$O%f!<%6$NL\@h$NMxJX@-$rM%@h$7$F?'!9$J5!G=$r8@8lMWAG$H$7$F<h$jF~$l$k>l9g$,B?$$$N$G$9$,!"(BPython $B$G$O$=$&$$$C$?>.:Y9)$,DI2C$5$l$k$3$H$O$"$^$j$"$j$^$;$s!#(B
+$B8@8l<+BN$N5!G=$O:G>.8B$K2!$5$(!"I,MW$J5!G=$O3HD%%b%8%e!<%k$H$7$FDI2C$9$k!"$H$$$&$N$,(B Python $B$N%]%j%7!<$G$9!#(B
+

from_cpython/Lib/test/cjkencodings/iso2022_kr-utf8.txt

+◎ 파이썬(Python)은 배우기 쉽고, 강력한 프로그래밍 언어입니다. 파이썬은
+효율적인 고수준 데이터 구조와 간단하지만 효율적인 객체지향프로그래밍을
+지원합니다. 파이썬의 우아(優雅)한 문법과 동적 타이핑, 그리고 인터프리팅
+환경은 파이썬을 스크립팅과 여러 분야에서와 대부분의 플랫폼에서의 빠른
+애플리케이션 개발을 할 수 있는 이상적인 언어로 만들어줍니다.
+
+☆첫가끝: 날아라 쓩~ 큼! 금없이 전니다. 그런거 다.

from_cpython/Lib/test/cjkencodings/iso2022_kr.txt

+$)C!] FD@L=c(Python)@: 9h?l1b =10m, 0-7BGQ GA7N1W7!9V >p>n@T4O4Y. FD@L=c@:
+H?@2@{@N 0m<vAX 5%@LEM 18A6?M 0#4\GOAv88 H?@2@{@N 04C<AvGbGA7N1W7!9V@;
+Av?xGU4O4Y. FD@L=c@G ?l>F(iPd:)GQ 9.9}0z 5?@{ E8@LGN, 1W8.0m @NEMGA8.FC
+H/0f@: FD@L=c@; =:E)83FC0z ?)7/ :P>_?!<-?M 4k:N:P@G GC7'F{?!<-@G :|8%
+>VGC8.DI@L<G 039_@; GR <v @V4B @L;s@{@N >p>n7N 885i>nA]4O4Y.
+
+!YC90!3!: 3/>F6s >1~ E-! 1]>x@L @|4O4Y. 1W710E 4Y.

from_cpython/Lib/test/cjkencodings/johab-utf8.txt

+똠방각하 펲시콜라
+
+㉯㉯납!! 因九月패믤릔궈 ⓡⓖ훀¿¿¿ 긍뒙 ⓔ뎨 ㉯. .
+亞영ⓔ능횹 . . . . 서울뤄 뎐학乙 家훀 ! ! !ㅠ.ㅠ
+흐흐흐 ㄱㄱㄱ☆ㅠ_ㅠ 어릨 탸콰긐 뎌응 칑九들乙 ㉯드긐
+설릌 家훀 . . . . 굴애쉌 ⓔ궈 ⓡ릘㉱긐 因仁川女中까즼
+와쒀훀 ! ! 亞영ⓔ 家능궈 ☆上관 없능궈능 亞능뒈훀 글애듴
+ⓡ려듀九 싀풔숴훀 어릨 因仁川女中싁⑨들앜!! ㉯㉯납♡ ⌒⌒*
+

from_cpython/Lib/test/cjkencodings/johab.txt

+wba \ũa
+
+s!! gÚ zٯٯٯ w ѕ . .
+<wѓws . . . . ᶉ eb ;z ! ! !A.A
+aaa AAAiA_A ៚ ȡz aw ×✗i az
+z ;z . . . .  ъ ޟ‹z gbIa
+z ! ! <w ;w i꾉 ww <wz iz
+ޝaA Ρz ៚ gbI鯂iz!! sٽ bb*
+

from_cpython/Lib/test/cjkencodings/shift_jis-utf8.txt

+Python の開発は、1990 年ごろから開始されています。
+開発者の Guido van Rossum は教育用のプログラミング言語「ABC」の開発に参加していましたが、ABC は実用上の目的にはあまり適していませんでした。
+このため、Guido はより実用的なプログラミング言語の開発を開始し、英国 BBS 放送のコメディ番組「モンティ パイソン」のファンである Guido はこの言語を「Python」と名づけました。
+このような背景から生まれた Python の言語設計は、「シンプル」で「習得が容易」という目標に重点が置かれています。
+多くのスクリプト系言語ではユーザの目先の利便性を優先して色々な機能を言語要素として取り入れる場合が多いのですが、Python ではそういった小細工が追加されることはあまりありません。
+言語自体の機能は最小限に押さえ、必要な機能は拡張モジュールとして追加する、というのが Python のポリシーです。
+

from_cpython/Lib/test/cjkencodings/shift_jis.txt

+Python の開発は、1990 年ごろから開始されています。
+開発者の Guido van Rossum は教育用のプログラミング言語「ABC」の開発に参加していましたが、ABC は実用上の目的にはあまり適していませんでした。
+このため、Guido はより実用的なプログラミング言語の開発を開始し、英国 BBS 放送のコメディ番組「モンティ パイソン」のファンである Guido はこの言語を「Python」と名づけました。
+このような背景から生まれた Python の言語設計は、「シンプル」で「習得が容易」という目標に重点が置かれています。
+多くのスクリプト系言語ではユーザの目先の利便性を優先して色々な機能を言語要素として取り入れる場合が多いのですが、Python ではそういった小細工が追加されることはあまりありません。
+言語自体の機能は最小限に押さえ、必要な機能は拡張モジュールとして追加する、というのが Python のポリシーです。
+

from_cpython/Lib/test/cjkencodings/shift_jisx0213-utf8.txt

+Python の開発は、1990 年ごろから開始されています。
+開発者の Guido van Rossum は教育用のプログラミング言語「ABC」の開発に参加していましたが、ABC は実用上の目的にはあまり適していませんでした。
+このため、Guido はより実用的なプログラミング言語の開発を開始し、英国 BBS 放送のコメディ番組「モンティ パイソン」のファンである Guido はこの言語を「Python」と名づけました。
+このような背景から生まれた Python の言語設計は、「シンプル」で「習得が容易」という目標に重点が置かれています。
+多くのスクリプト系言語ではユーザの目先の利便性を優先して色々な機能を言語要素として取り入れる場合が多いのですが、Python ではそういった小細工が追加されることはあまりありません。
+言語自体の機能は最小限に押さえ、必要な機能は拡張モジュールとして追加する、というのが Python のポリシーです。
+
+ノか゚ ト゚ トキ喝塀 𡚴𪎌 麀齁𩛰

from_cpython/Lib/test/cjkencodings/shift_jisx0213.txt

+Python の開発は、1990 年ごろから開始されています。
+開発者の Guido van Rossum は教育用のプログラミング言語「ABC」の開発に参加していましたが、ABC は実用上の目的にはあまり適していませんでした。
+このため、Guido はより実用的なプログラミング言語の開発を開始し、英国 BBS 放送のコメディ番組「モンティ パイソン」のファンである Guido はこの言語を「Python」と名づけました。
+このような背景から生まれた Python の言語設計は、「シンプル」で「習得が容易」という目標に重点が置かれています。
+多くのスクリプト系言語ではユーザの目先の利便性を優先して色々な機能を言語要素として取り入れる場合が多いのですが、Python ではそういった小細工が追加されることはあまりありません。
+言語自体の機能は最小限に押さえ、必要な機能は拡張モジュールとして追加する、というのが Python のポリシーです。
+
+ノ  トキ  

from_cpython/Lib/test/crashers/README

+This directory only contains tests for outstanding bugs that cause the
+interpreter to segfault.  Ideally this directory should always be empty, but
+sometimes it may not be easy to fix the underlying cause and the bug is deemed
+too obscure to invest the effort.
+
+Each test should fail when run from the command line:
+
+	./python Lib/test/crashers/weakref_in_del.py
+
+Put as much info into a docstring or comments to help determine the cause of the
+failure, as well as a bugs.python.org issue number if it exists.  Particularly
+note if the cause is system or environment dependent and what the variables are.
+
+Once the crash is fixed, the test case should be moved into an appropriate test
+(even if it was originally from the test suite).  This ensures the regression
+doesn't happen again.  And if it does, it should be easier to track down.

from_cpython/Lib/test/crashers/bogus_code_obj.py

+"""
+Broken bytecode objects can easily crash the interpreter.
+
+This is not going to be fixed.  It is generally agreed that there is no
+point in writing a bytecode verifier and putting it in CPython just for
+this.  Moreover, a verifier is bound to accept only a subset of all safe
+bytecodes, so it could lead to unnecessary breakage.
+
+For security purposes, "restricted" interpreters are not going to let
+the user build or load random bytecodes anyway.  Otherwise, this is a
+"won't fix" case.
+
+"""
+
+import types
+
+co = types.CodeType(0, 0, 0, 0, '\x04\x71\x00\x00', (),
+                    (), (), '', '', 1, '')
+exec co

from_cpython/Lib/test/crashers/borrowed_ref_1.py

+"""
+_PyType_Lookup() returns a borrowed reference.
+This attacks the call in dictobject.c.
+"""
+
+class A(object):
+    pass
+
+class B(object):
+    def __del__(self):
+        print 'hi'
+        del D.__missing__
+
+class D(dict):
+    class __missing__:
+        def __init__(self, *args):
+            pass
+
+
+d = D()
+a = A()
+a.cycle = a
+a.other = B()
+del a
+
+prev = None
+while 1:
+    d[5]
+    prev = (prev,)

from_cpython/Lib/test/crashers/borrowed_ref_2.py

+"""
+_PyType_Lookup() returns a borrowed reference.
+This attacks PyObject_GenericSetAttr().
+
+NB. on my machine this crashes in 2.5 debug but not release.
+"""
+
+class A(object):
+    pass
+
+class B(object):
+    def __del__(self):
+        print "hi"
+        del C.d
+
+class D(object):
+    def __set__(self, obj, value):
+        self.hello = 42
+
+class C(object):
+    d = D()
+
+    def g():
+        pass
+
+
+c = C()
+a = A()
+a.cycle = a
+a.other = B()
+
+lst = [None] * 1000000
+i = 0
+del a
+while 1:
+    c.d = 42         # segfaults in PyMethod_New(im_func=D.__set__, im_self=d)
+    lst[i] = c.g     # consume the free list of instancemethod objects
+    i += 1

from_cpython/Lib/test/crashers/buffer_mutate.py

+#
+# The various methods of bufferobject.c (here buffer_subscript()) call
+# get_buf() before calling potentially more Python code (here via
+# PySlice_GetIndicesEx()).  But get_buf() already returned a void*
+# pointer.  This void* pointer can become invalid if the object
+# underlying the buffer is mutated (here a bytearray object).
+#
+# As usual, please keep in mind that the three "here" in the sentence
+# above are only examples.  Each can be changed easily and lead to
+# another crasher.
+#
+# This crashes for me on Linux 32-bits with CPython 2.6 and 2.7
+# with a segmentation fault.
+#
+
+
+class PseudoIndex(object):
+    def __index__(self):
+        for c in "foobar"*n:
+            a.append(c)
+        return n * 4
+
+
+for n in range(1, 100000, 100):
+    a = bytearray("test"*n)
+    buf = buffer(a)
+
+    s = buf[:PseudoIndex():1]
+    #print repr(s)
+    #assert s == "test"*n

from_cpython/Lib/test/crashers/compiler_recursion.py

+"""
+The compiler (>= 2.5) recurses happily.
+"""
+
+compile('()'*9**5, '?', 'exec')

from_cpython/Lib/test/crashers/decref_before_assignment.py

+"""
+General example for an attack against code like this:
+
+    Py_DECREF(obj->attr); obj->attr = ...;
+
+here in Module/_json.c:scanner_init().
+
+Explanation: if the first Py_DECREF() calls either a __del__ or a
+weakref callback, it will run while the 'obj' appears to have in
+'obj->attr' still the old reference to the object, but not holding
+the reference count any more.
+
+Status: progress has been made replacing these cases, but there is an
+infinite number of such cases.
+"""
+
+import _json, weakref
+
+class Ctx1(object):
+    encoding = "utf8"
+    strict = None
+    object_hook = None
+    object_pairs_hook = None
+    parse_float = None
+    parse_int = None
+    parse_constant = None
+
+class Foo(unicode):
+    pass
+
+def delete_me(*args):
+    print scanner.encoding.__dict__
+
+class Ctx2(Ctx1):
+    @property
+    def encoding(self):
+        global wref
+        f = Foo("utf8")
+        f.abc = globals()
+        wref = weakref.ref(f, delete_me)
+        return f
+
+scanner = _json.make_scanner(Ctx1())
+scanner.__init__(Ctx2())

from_cpython/Lib/test/crashers/gc_has_finalizer.py

+"""
+The gc module can still invoke arbitrary Python code and crash.
+This is an attack against _PyInstance_Lookup(), which is documented
+as follows:
+
+    The point of this routine is that it never calls arbitrary Python
+    code, so is always "safe":  all it does is dict lookups.
+
+But of course dict lookups can call arbitrary Python code.
+The following code causes mutation of the object graph during
+the call to has_finalizer() in gcmodule.c, and that might
+segfault.
+"""
+
+import gc
+
+
+class A:
+    def __hash__(self):
+        return hash("__del__")
+    def __eq__(self, other):
+        del self.other
+        return False
+
+a = A()
+b = A()
+
+a.__dict__[b] = 'A'
+
+a.other = b
+b.other = a
+
+gc.collect()
+del a, b
+
+gc.collect()

from_cpython/Lib/test/crashers/gc_inspection.py

+"""
+gc.get_referrers() can be used to see objects before they are fully built.
+
+Note that this is only an example.  There are many ways to crash Python
+by using gc.get_referrers(), as well as many extension modules (even
+when they are using perfectly documented patterns to build objects).
+
+Identifying and removing all places that expose to the GC a
+partially-built object is a long-term project.  A patch was proposed on
+SF specifically for this example but I consider fixing just this single
+example a bit pointless (#1517042).
+
+A fix would include a whole-scale code review, possibly with an API
+change to decouple object creation and GC registration, and according
+fixes to the documentation for extension module writers.  It's unlikely
+to happen, though.  So this is currently classified as
+"gc.get_referrers() is dangerous, use only for debugging".
+"""
+
+import gc
+
+
+def g():
+    marker = object()
+    yield marker
+    # now the marker is in the tuple being constructed
+    [tup] = [x for x in gc.get_referrers(marker) if type(x) is tuple]
+    print tup
+    print tup[1]
+
+
+tuple(g())

from_cpython/Lib/test/crashers/infinite_loop_re.py

+
+# This was taken from http://python.org/sf/1541697
+# It's not technically a crasher.  It may not even truly be infinite,
+# however, I haven't waited a long time to see the result.  It takes
+# 100% of CPU while running this and should be fixed.
+
+import re
+starttag = re.compile(r'<[a-zA-Z][-_.:a-zA-Z0-9]*\s*('
+        r'\s*([a-zA-Z_][-:.a-zA-Z_0-9]*)(\s*=\s*'
+        r'(\'[^\']*\'|"[^"]*"|[-a-zA-Z0-9./,:;+*%?!&$\(\)_#=~@]'
+        r'[][\-a-zA-Z0-9./,:;+*%?!&$\(\)_#=~\'"@]*(?=[\s>/<])))?'
+    r')*\s*/?\s*(?=[<>])')
+
+if __name__ == '__main__':
+    foo = '<table cellspacing="0" cellpadding="0" style="border-collapse'
+    starttag.match(foo)

from_cpython/Lib/test/crashers/loosing_mro_ref.py

+"""
+There is a way to put keys of any type in a type's dictionary.
+I think this allows various kinds of crashes, but so far I have only
+found a convoluted attack of _PyType_Lookup(), which uses the mro of the
+type without holding a strong reference to it.  Probably works with
+super.__getattribute__() too, which uses the same kind of code.
+"""
+
+class MyKey(object):
+    def __hash__(self):
+        return hash('mykey')
+
+    def __cmp__(self, other):
+        # the following line decrefs the previous X.__mro__
+        X.__bases__ = (Base2,)
+        # trash all tuples of length 3, to make sure that the items of
+        # the previous X.__mro__ are really garbage
+        z = []
+        for i in range(1000):
+            z.append((i, None, None))
+        return -1
+
+
+class Base(object):
+    mykey = 'from Base'
+
+class Base2(object):
+    mykey = 'from Base2'
+
+# you can't add a non-string key to X.__dict__, but it can be
+# there from the beginning :-)
+X = type('X', (Base,), {MyKey(): 5})
+
+print X.mykey
+# I get a segfault, or a slightly wrong assertion error in a debug build.

from_cpython/Lib/test/crashers/mutation_inside_cyclegc.py

+
+# The cycle GC collector can be executed when any GC-tracked object is
+# allocated, e.g. during a call to PyList_New(), PyDict_New(), ...
+# Moreover, it can invoke arbitrary Python code via a weakref callback.
+# This means that there are many places in the source where an arbitrary
+# mutation could unexpectedly occur.
+
+# The example below shows list_slice() not expecting the call to
+# PyList_New to mutate the input list.  (Of course there are many
+# more examples like this one.)
+
+
+import weakref
+
+class A(object):
+    pass
+
+def callback(x):
+    del lst[:]
+
+
+keepalive = []
+
+for i in range(100):
+    lst = [str(i)]
+    a = A()
+    a.cycle = a
+    keepalive.append(weakref.ref(a, callback))
+    del a
+    while lst:
+        keepalive.append(lst[:])

from_cpython/Lib/test/crashers/nasty_eq_vs_dict.py

+# from http://mail.python.org/pipermail/python-dev/2001-June/015239.html
+
+# if you keep changing a dictionary while looking up a key, you can
+# provoke an infinite recursion in C
+
+# At the time neither Tim nor Michael could be bothered to think of a
+# way to fix it.
+
+class Yuck:
+    def __init__(self):
+        self.i = 0
+
+    def make_dangerous(self):
+        self.i = 1
+
+    def __hash__(self):
+        # direct to slot 4 in table of size 8; slot 12 when size 16
+        return 4 + 8
+
+    def __eq__(self, other):
+        if self.i == 0:
+            # leave dict alone
+            pass
+        elif self.i == 1:
+            # fiddle to 16 slots
+            self.__fill_dict(6)
+            self.i = 2
+        else:
+            # fiddle to 8 slots
+            self.__fill_dict(4)
+            self.i = 1
+
+        return 1
+
+    def __fill_dict(self, n):
+        self.i = 0
+        dict.clear()
+        for i in range(n):
+            dict[i] = i
+        dict[self] = "OK!"
+
+y = Yuck()
+dict = {y: "OK!"}
+
+z = Yuck()
+y.make_dangerous()
+print dict[z]

from_cpython/Lib/test/crashers/recursion_limit_too_high.py

+# The following example may crash or not depending on the platform.
+# E.g. on 32-bit Intel Linux in a "standard" configuration it seems to
+# crash on Python 2.5 (but not 2.4 nor 2.3).  On Windows the import
+# eventually fails to find the module, possibly because we run out of
+# file handles.
+
+# The point of this example is to show that sys.setrecursionlimit() is a
+# hack, and not a robust solution.  This example simply exercises a path
+# where it takes many C-level recursions, consuming a lot of stack
+# space, for each Python-level recursion.  So 1000 times this amount of
+# stack space may be too much for standard platforms already.
+
+import sys
+if 'recursion_limit_too_high' in sys.modules:
+    del sys.modules['recursion_limit_too_high']
+import recursion_limit_too_high

from_cpython/Lib/test/crashers/recursive_call.py

+#!/usr/bin/env python
+
+# No bug report AFAIK, mail on python-dev on 2006-01-10
+
+# This is a "won't fix" case.  It is known that setting a high enough
+# recursion limit crashes by overflowing the stack.  Unless this is
+# redesigned somehow, it won't go away.
+
+import sys
+
+sys.setrecursionlimit(1 << 30)
+f = lambda f:f(f)
+
+if __name__ == '__main__':
+    f(f)

from_cpython/Lib/test/curses_tests.py

+#!/usr/bin/env python
+#
+# $Id: ncurses.py 36559 2004-07-18 05:56:09Z tim_one $
+#
+# Interactive test suite for the curses module.
+# This script displays various things and the user should verify whether
+# they display correctly.
+#
+
+import curses
+from curses import textpad
+
+def test_textpad(stdscr, insert_mode=False):
+    ncols, nlines = 8, 3
+    uly, ulx = 3, 2
+    if insert_mode:
+        mode = 'insert mode'
+    else:
+        mode = 'overwrite mode'
+
+    stdscr.addstr(uly-3, ulx, "Use Ctrl-G to end editing (%s)." % mode)
+    stdscr.addstr(uly-2, ulx, "Be sure to try typing in the lower-right corner.")
+    win = curses.newwin(nlines, ncols, uly, ulx)
+    textpad.rectangle(stdscr, uly-1, ulx-1, uly + nlines, ulx + ncols)
+    stdscr.refresh()
+
+    box = textpad.Textbox(win, insert_mode)
+    contents = box.edit()
+    stdscr.addstr(uly+ncols+2, 0, "Text entered in the box\n")
+    stdscr.addstr(repr(contents))
+    stdscr.addstr('\n')
+    stdscr.addstr('Press any key')
+    stdscr.getch()
+
+    for i in range(3):
+        stdscr.move(uly+ncols+2 + i, 0)
+        stdscr.clrtoeol()
+
+def main(stdscr):
+    stdscr.clear()
+    test_textpad(stdscr, False)
+    test_textpad(stdscr, True)
+
+
+if __name__ == '__main__':
+    curses.wrapper(main)

from_cpython/Lib/test/data/README

+This empty directory serves as destination for temporary files
+created by some tests.

from_cpython/Lib/test/decimaltestdata/abs.decTest

+------------------------------------------------------------------------
+-- abs.decTest -- decimal absolute value                              --
+-- Copyright (c) IBM Corporation, 1981, 2008.  All rights reserved.   --
+------------------------------------------------------------------------
+-- Please see the document "General Decimal Arithmetic Testcases"     --
+-- at http://www2.hursley.ibm.com/decimal for the description of      --
+-- these testcases.                                                   --
+--                                                                    --
+-- These testcases are experimental ('beta' versions), and they       --
+-- may contain errors.  They are offered on an as-is basis.  In       --
+-- particular, achieving the same results as the tests here is not    --
+-- a guarantee that an implementation complies with any Standard      --
+-- or specification.  The tests are not exhaustive.                   --
+--                                                                    --
+-- Please send comments, suggestions, and corrections to the author:  --
+--   Mike Cowlishaw, IBM Fellow                                       --
+--   IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK         --
+--   mfc@uk.ibm.com                                                   --
+------------------------------------------------------------------------
+version: 2.59
+
+-- This set of tests primarily tests the existence of the operator.
+-- Additon, subtraction, rounding, and more overflows are tested
+-- elsewhere.
+
+precision:   9
+rounding:    half_up
+maxExponent: 384
+minexponent: -383
+extended: 1
+
+absx001 abs '1'      -> '1'
+absx002 abs '-1'     -> '1'
+absx003 abs '1.00'   -> '1.00'
+absx004 abs '-1.00'  -> '1.00'
+absx005 abs '0'      -> '0'
+absx006 abs '0.00'   -> '0.00'
+absx007 abs '00.0'   -> '0.0'
+absx008 abs '00.00'  -> '0.00'
+absx009 abs '00'     -> '0'
+
+absx010 abs '-2'     -> '2'
+absx011 abs '2'      -> '2'
+absx012 abs '-2.00'  -> '2.00'
+absx013 abs '2.00'   -> '2.00'
+absx014 abs '-0'     -> '0'
+absx015 abs '-0.00'  -> '0.00'
+absx016 abs '-00.0'  -> '0.0'
+absx017 abs '-00.00' -> '0.00'
+absx018 abs '-00'    -> '0'
+
+absx020 abs '-2000000' -> '2000000'
+absx021 abs '2000000'  -> '2000000'
+precision: 7
+absx022 abs '-2000000' -> '2000000'
+absx023 abs '2000000'  -> '2000000'
+precision: 6
+absx024 abs '-2000000' -> '2.00000E+6' Rounded
+absx025 abs '2000000'  -> '2.00000E+6' Rounded
+precision: 3
+absx026 abs '-2000000' -> '2.00E+6' Rounded
+absx027 abs '2000000'  -> '2.00E+6' Rounded
+
+absx030 abs '+0.1'            -> '0.1'
+absx031 abs '-0.1'            -> '0.1'
+absx032 abs '+0.01'           -> '0.01'
+absx033 abs '-0.01'           -> '0.01'
+absx034 abs '+0.001'          -> '0.001'
+absx035 abs '-0.001'          -> '0.001'
+absx036 abs '+0.000001'       -> '0.000001'
+absx037 abs '-0.000001'       -> '0.000001'
+absx038 abs '+0.000000000001' -> '1E-12'
+absx039 abs '-0.000000000001' -> '1E-12'
+
+-- examples from decArith
+precision: 9
+absx040 abs '2.1'     ->  '2.1'
+absx041 abs '-100'    ->  '100'
+absx042 abs '101.5'   ->  '101.5'
+absx043 abs '-101.5'  ->  '101.5'
+
+-- more fixed, potential LHS swaps/overlays if done by subtract 0
+precision: 9
+absx060 abs '-56267E-10'  -> '0.0000056267'
+absx061 abs '-56267E-5'   -> '0.56267'
+absx062 abs '-56267E-2'   -> '562.67'
+absx063 abs '-56267E-1'   -> '5626.7'
+absx065 abs '-56267E-0'   -> '56267'
+
+-- overflow tests
+maxexponent: 999999999
+minexponent: -999999999
+precision: 3
+absx120 abs 9.999E+999999999 -> Infinity Inexact Overflow Rounded
+
+-- subnormals and underflow
+precision: 3
+maxexponent: 999
+minexponent: -999
+absx210 abs  1.00E-999        ->   1.00E-999
+absx211 abs  0.1E-999         ->   1E-1000   Subnormal
+absx212 abs  0.10E-999        ->   1.0E-1000 Subnormal
+absx213 abs  0.100E-999       ->   1.0E-1000 Subnormal Rounded
+absx214 abs  0.01E-999        ->   1E-1001   Subnormal
+-- next is rounded to Emin
+absx215 abs  0.999E-999       ->   1.00E-999 Inexact Rounded Subnormal Underflow
+absx216 abs  0.099E-999       ->   1.0E-1000 Inexact Rounded Subnormal Underflow
+absx217 abs  0.009E-999       ->   1E-1001   Inexact Rounded Subnormal Underflow
+absx218 abs  0.001E-999       ->   0E-1001   Inexact Rounded Subnormal Underflow Clamped
+absx219 abs  0.0009E-999      ->   0E-1001   Inexact Rounded Subnormal Underflow Clamped
+absx220 abs  0.0001E-999      ->   0E-1001   Inexact Rounded Subnormal Underflow Clamped
+
+absx230 abs -1.00E-999        ->   1.00E-999
+absx231 abs -0.1E-999         ->   1E-1000   Subnormal
+absx232 abs -0.10E-999        ->   1.0E-1000 Subnormal
+absx233 abs -0.100E-999       ->   1.0E-1000 Subnormal Rounded
+absx234 abs -0.01E-999        ->   1E-1001   Subnormal
+-- next is rounded to Emin
+absx235 abs -0.999E-999       ->   1.00E-999 Inexact Rounded Subnormal Underflow
+absx236 abs -0.099E-999       ->   1.0E-1000 Inexact Rounded Subnormal Underflow
+absx237 abs -0.009E-999       ->   1E-1001   Inexact Rounded Subnormal Underflow
+absx238 abs -0.001E-999       ->   0E-1001   Inexact Rounded Subnormal Underflow Clamped
+absx239 abs -0.0009E-999      ->   0E-1001   Inexact Rounded Subnormal Underflow Clamped
+absx240 abs -0.0001E-999      ->   0E-1001   Inexact Rounded Subnormal Underflow Clamped
+
+-- long operand tests
+maxexponent: 999
+minexponent: -999
+precision: 9
+absx301 abs 12345678000  -> 1.23456780E+10 Rounded
+absx302 abs 1234567800   -> 1.23456780E+9 Rounded
+absx303 abs 1234567890   -> 1.23456789E+9 Rounded
+absx304 abs 1234567891   -> 1.23456789E+9 Inexact Rounded
+absx305 abs 12345678901  -> 1.23456789E+10 Inexact Rounded
+absx306 abs 1234567896   -> 1.23456790E+9 Inexact Rounded
+
+precision: 15
+absx321 abs 12345678000  -> 12345678000
+absx322 abs 1234567800   -> 1234567800
+absx323 abs 1234567890   -> 1234567890
+absx324 abs 1234567891   -> 1234567891
+absx325 abs 12345678901  -> 12345678901
+absx326 abs 1234567896   -> 1234567896
+
+
+-- Specials
+precision:   9
+
+-- specials
+absx520 abs 'Inf'    -> 'Infinity'
+absx521 abs '-Inf'   -> 'Infinity'
+absx522 abs   NaN    ->  NaN
+absx523 abs  sNaN    ->  NaN   Invalid_operation
+absx524 abs   NaN22  ->  NaN22
+absx525 abs  sNaN33  ->  NaN33 Invalid_operation
+absx526 abs  -NaN22  -> -NaN22
+absx527 abs -sNaN33  -> -NaN33 Invalid_operation
+
+-- Null tests
+absx900 abs  # -> NaN Invalid_operation
+

from_cpython/Lib/test/decimaltestdata/class.decTest

+------------------------------------------------------------------------
+-- class.decTest -- Class operations                                  --
+-- Copyright (c) IBM Corporation, 1981, 2008.  All rights reserved.   --
+------------------------------------------------------------------------
+-- Please see the document "General Decimal Arithmetic Testcases"     --
+-- at http://www2.hursley.ibm.com/decimal for the description of      --
+-- these testcases.                                                   --
+--                                                                    --
+-- These testcases are experimental ('beta' versions), and they       --
+-- may contain errors.  They are offered on an as-is basis.  In       --
+-- particular, achieving the same results as the tests here is not    --
+-- a guarantee that an implementation complies with any Standard      --
+-- or specification.  The tests are not exhaustive.                   --
+--                                                                    --
+-- Please send comments, suggestions, and corrections to the author:  --
+--   Mike Cowlishaw, IBM Fellow                                       --
+--   IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK         --
+--   mfc@uk.ibm.com                                                   --
+------------------------------------------------------------------------
+version: 2.59
+
+-- [New 2006.11.27]
+
+precision:   9
+maxExponent: 999
+minExponent: -999
+extended:    1
+clamp:       1
+rounding:    half_even
+
+clasx001  class    0                        -> +Zero
+clasx002  class    0.00                     -> +Zero
+clasx003  class    0E+5                     -> +Zero
+clasx004  class    1E-1007                  -> +Subnormal
+clasx005  class  0.1E-999                   -> +Subnormal
+clasx006  class  0.99999999E-999            -> +Subnormal
+clasx007  class  1.00000000E-999            -> +Normal
+clasx008  class   1E-999                    -> +Normal
+clasx009  class   1E-100                    -> +Normal
+clasx010  class   1E-10                     -> +Normal
+clasx012  class   1E-1                      -> +Normal
+clasx013  class   1                         -> +Normal
+clasx014  class   2.50                      -> +Normal
+clasx015  class   100.100                   -> +Normal
+clasx016  class   1E+30                     -> +Normal
+clasx017  class   1E+999                    -> +Normal
+clasx018  class   9.99999999E+999           -> +Normal
+clasx019  class   Inf                       -> +Infinity
+
+clasx021  class   -0                        -> -Zero
+clasx022  class   -0.00                     -> -Zero
+clasx023  class   -0E+5                     -> -Zero
+clasx024  class   -1E-1007                  -> -Subnormal
+clasx025  class  -0.1E-999                  -> -Subnormal
+clasx026  class  -0.99999999E-999           -> -Subnormal
+clasx027  class  -1.00000000E-999           -> -Normal
+clasx028  class  -1E-999                    -> -Normal
+clasx029  class  -1E-100                    -> -Normal
+clasx030  class  -1E-10                     -> -Normal
+clasx032  class  -1E-1                      -> -Normal
+clasx033  class  -1                         -> -Normal
+clasx034  class  -2.50                      -> -Normal
+clasx035  class  -100.100                   -> -Normal
+clasx036  class  -1E+30                     -> -Normal
+clasx037  class  -1E+999                    -> -Normal
+clasx038  class  -9.99999999E+999           -> -Normal
+clasx039  class  -Inf                       -> -Infinity
+
+clasx041  class   NaN                       -> NaN
+clasx042  class  -NaN                       -> NaN
+clasx043  class  +NaN12345                  -> NaN
+clasx044  class   sNaN                      -> sNaN
+clasx045  class  -sNaN                      -> sNaN
+clasx046  class  +sNaN12345                 -> sNaN
+
+
+-- decimal64 bounds
+
+precision:   16
+maxExponent: 384
+minExponent: -383
+clamp:       1
+rounding:    half_even
+
+clasx201  class    0                        -> +Zero
+clasx202  class    0.00                     -> +Zero
+clasx203  class    0E+5                     -> +Zero
+clasx204  class    1E-396                   -> +Subnormal
+clasx205  class  0.1E-383                   -> +Subnormal
+clasx206  class  0.999999999999999E-383     -> +Subnormal
+clasx207  class  1.000000000000000E-383     -> +Normal
+clasx208  class   1E-383                    -> +Normal
+clasx209  class   1E-100                    -> +Normal
+clasx210  class   1E-10                     -> +Normal
+clasx212  class   1E-1                      -> +Normal
+clasx213  class   1                         -> +Normal
+clasx214  class   2.50                      -> +Normal
+clasx215  class   100.100                   -> +Normal
+clasx216  class   1E+30                     -> +Normal
+clasx217  class   1E+384                    -> +Normal
+clasx218  class   9.999999999999999E+384    -> +Normal
+clasx219  class   Inf                       -> +Infinity
+
+clasx221  class   -0                        -> -Zero
+clasx222  class   -0.00                     -> -Zero
+clasx223  class   -0E+5                     -> -Zero
+clasx224  class   -1E-396                   -> -Subnormal
+clasx225  class  -0.1E-383                  -> -Subnormal
+clasx226  class  -0.999999999999999E-383    -> -Subnormal
+clasx227  class  -1.000000000000000E-383    -> -Normal
+clasx228  class  -1E-383                    -> -Normal
+clasx229  class  -1E-100                    -> -Normal
+clasx230  class  -1E-10                     -> -Normal
+clasx232  class  -1E-1                      -> -Normal
+clasx233  class  -1                         -> -Normal
+clasx234  class  -2.50                      -> -Normal
+clasx235  class  -100.100                   -> -Normal
+clasx236  class  -1E+30                     -> -Normal
+clasx237  class  -1E+384                    -> -Normal
+clasx238  class  -9.999999999999999E+384    -> -Normal
+clasx239  class  -Inf                       -> -Infinity
+
+clasx241  class   NaN                       -> NaN
+clasx242  class  -NaN                       -> NaN
+clasx243  class  +NaN12345                  -> NaN
+clasx244  class   sNaN                      -> sNaN
+clasx245  class  -sNaN                      -> sNaN
+clasx246  class  +sNaN12345                 -> sNaN
+
+
+

from_cpython/Lib/test/decimaltestdata/copy.decTest

+------------------------------------------------------------------------
+-- copy.decTest -- quiet copy                                         --
+-- Copyright (c) IBM Corporation, 1981, 2008.  All rights reserved.   --
+------------------------------------------------------------------------
+-- Please see the document "General Decimal Arithmetic Testcases"     --
+-- at http://www2.hursley.ibm.com/decimal for the description of      --
+-- these testcases.                                                   --
+--                                                                    --
+-- These testcases are experimental ('beta' versions), and they       --
+-- may contain errors.  They are offered on an as-is basis.  In       --
+-- particular, achieving the same results as the tests here is not    --
+-- a guarantee that an implementation complies with any Standard      --
+-- or specification.  The tests are not exhaustive.                   --
+--                                                                    --
+-- Please send comments, suggestions, and corrections to the author:  --
+--   Mike Cowlishaw, IBM Fellow                                       --
+--   IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK         --
+--   mfc@uk.ibm.com                                                   --
+------------------------------------------------------------------------
+version: 2.59
+
+extended:    1
+precision:   9
+rounding:    half_up
+maxExponent: 999
+minExponent: -999
+
+-- Sanity check
+cpyx001 copy       +7.50  -> 7.50
+
+-- Infinities
+cpyx011 copy  Infinity    -> Infinity
+cpyx012 copy  -Infinity   -> -Infinity
+
+-- NaNs, 0 payload
+cpyx021 copy         NaN  -> NaN
+cpyx022 copy        -NaN  -> -NaN
+cpyx023 copy        sNaN  -> sNaN
+cpyx024 copy       -sNaN  -> -sNaN
+
+-- NaNs, non-0 payload
+cpyx031 copy       NaN10  -> NaN10
+cpyx032 copy      -NaN10  -> -NaN10
+cpyx033 copy      sNaN10  -> sNaN10
+cpyx034 copy     -sNaN10  -> -sNaN10
+cpyx035 copy       NaN7   -> NaN7
+cpyx036 copy      -NaN7   -> -NaN7
+cpyx037 copy      sNaN101 -> sNaN101
+cpyx038 copy     -sNaN101 -> -sNaN101
+
+-- finites
+cpyx101 copy          7   -> 7
+cpyx102 copy         -7   -> -7
+cpyx103 copy         75   -> 75
+cpyx104 copy        -75   -> -75
+cpyx105 copy       7.50   -> 7.50
+cpyx106 copy      -7.50   -> -7.50
+cpyx107 copy       7.500  -> 7.500
+cpyx108 copy      -7.500  -> -7.500
+
+-- zeros
+cpyx111 copy          0   -> 0
+cpyx112 copy         -0   -> -0
+cpyx113 copy       0E+4   -> 0E+4
+cpyx114 copy      -0E+4   -> -0E+4
+cpyx115 copy     0.0000   -> 0.0000
+cpyx116 copy    -0.0000   -> -0.0000
+cpyx117 copy      0E-141  -> 0E-141
+cpyx118 copy     -0E-141  -> -0E-141
+
+-- full coefficients, alternating bits
+cpyx121 copy   268268268        -> 268268268
+cpyx122 copy  -268268268        -> -268268268
+cpyx123 copy   134134134        -> 134134134
+cpyx124 copy  -134134134        -> -134134134
+
+-- Nmax, Nmin, Ntiny
+cpyx131 copy  9.99999999E+999   -> 9.99999999E+999
+cpyx132 copy  1E-999            -> 1E-999
+cpyx133 copy  1.00000000E-999   -> 1.00000000E-999
+cpyx134 copy  1E-1007           -> 1E-1007
+
+cpyx135 copy  -1E-1007          -> -1E-1007
+cpyx136 copy  -1.00000000E-999  -> -1.00000000E-999
+cpyx137 copy  -1E-999           -> -1E-999
+cpyx138 copy  -9.99999999E+999  -> -9.99999999E+999

from_cpython/Lib/test/decimaltestdata/copyabs.decTest

+------------------------------------------------------------------------
+-- copyAbs.decTest -- quiet copy and set sign to zero                 --
+-- Copyright (c) IBM Corporation, 1981, 2008.  All rights reserved.   --
+------------------------------------------------------------------------
+-- Please see the document "General Decimal Arithmetic Testcases"     --
+-- at http://www2.hursley.ibm.com/decimal for the description of      --
+-- these testcases.                                                   --
+--                                                                    --
+-- These testcases are experimental ('beta' versions), and they       --
+-- may contain errors.  They are offered on an as-is basis.  In       --
+-- particular, achieving the same results as the tests here is not    --
+-- a guarantee that an implementation complies with any Standard      --
+-- or specification.  The tests are not exhaustive.                   --
+--                                                                    --
+-- Please send comments, suggestions, and corrections to the author:  --
+--   Mike Cowlishaw, IBM Fellow                                       --
+--   IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK         --
+--   mfc@uk.ibm.com                                                   --
+------------------------------------------------------------------------
+version: 2.59
+
+extended:    1
+precision:   9
+rounding:    half_up
+maxExponent: 999
+minExponent: -999
+
+-- Sanity check
+cpax001 copyabs       +7.50  -> 7.50
+
+-- Infinities
+cpax011 copyabs  Infinity    -> Infinity
+cpax012 copyabs  -Infinity   -> Infinity
+
+-- NaNs, 0 payload
+cpax021 copyabs         NaN  -> NaN
+cpax022 copyabs        -NaN  -> NaN
+cpax023 copyabs        sNaN  -> sNaN
+cpax024 copyabs       -sNaN  -> sNaN
+
+-- NaNs, non-0 payload
+cpax031 copyabs       NaN10  -> NaN10
+cpax032 copyabs      -NaN15  -> NaN15
+cpax033 copyabs      sNaN15  -> sNaN15
+cpax034 copyabs     -sNaN10  -> sNaN10
+cpax035 copyabs       NaN7   -> NaN7
+cpax036 copyabs      -NaN7   -> NaN7
+cpax037 copyabs      sNaN101 -> sNaN101
+cpax038 copyabs     -sNaN101 -> sNaN101
+
+-- finites
+cpax101 copyabs          7   -> 7
+cpax102 copyabs         -7   -> 7
+cpax103 copyabs         75   -> 75
+cpax104 copyabs        -75   -> 75
+cpax105 copyabs       7.10   -> 7.10
+cpax106 copyabs      -7.10   -> 7.10
+cpax107 copyabs       7.500  -> 7.500
+cpax108 copyabs      -7.500  -> 7.500
+
+-- zeros
+cpax111 copyabs          0   -> 0
+cpax112 copyabs         -0   -> 0
+cpax113 copyabs       0E+6   -> 0E+6
+cpax114 copyabs      -0E+6   -> 0E+6
+cpax115 copyabs     0.0000   -> 0.0000
+cpax116 copyabs    -0.0000   -> 0.0000
+cpax117 copyabs      0E-141  -> 0E-141
+cpax118 copyabs     -0E-141  -> 0E-141
+
+-- full coefficients, alternating bits
+cpax121 copyabs   268268268        -> 268268268
+cpax122 copyabs  -268268268        -> 268268268
+cpax123 copyabs   134134134        -> 134134134
+cpax124 copyabs  -134134134        -> 134134134
+
+-- Nmax, Nmin, Ntiny
+cpax131 copyabs  9.99999999E+999   -> 9.99999999E+999
+cpax132 copyabs  1E-999            -> 1E-999
+cpax133 copyabs  1.00000000E-999   -> 1.00000000E-999
+cpax134 copyabs  1E-1007           -> 1E-1007
+
+cpax135 copyabs  -1E-1007          -> 1E-1007
+cpax136 copyabs  -1.00000000E-999  -> 1.00000000E-999
+cpax137 copyabs  -1E-999           -> 1E-999
+cpax199 copyabs  -9.99999999E+999  -> 9.99999999E+999

from_cpython/Lib/test/decimaltestdata/copynegate.decTest

+------------------------------------------------------------------------
+-- copyNegate.decTest -- quiet copy and negate                        --
+-- Copyright (c) IBM Corporation, 1981, 2008.  All rights reserved.   --
+------------------------------------------------------------------------
+-- Please see the document "General Decimal Arithmetic Testcases"     --
+-- at http://www2.hursley.ibm.com/decimal for the description of      --
+-- these testcases.                                                   --
+--                                                                    --
+-- These testcases are experimental ('beta' versions), and they       --
+-- may contain errors.  They are offered on an as-is basis.  In       --
+-- particular, achieving the same results as the tests here is not    --
+-- a guarantee that an implementation complies with any Standard      --
+-- or specification.  The tests are not exhaustive.                   --
+--                                                                    --
+-- Please send comments, suggestions, and corrections to the author:  --
+--   Mike Cowlishaw, IBM Fellow                                       --
+--   IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK         --
+--   mfc@uk.ibm.com                                                   --
+------------------------------------------------------------------------
+version: 2.59
+
+extended:    1
+precision:   9
+rounding:    half_up
+maxExponent: 999
+minExponent: -999
+
+-- Sanity check
+cpnx001 copynegate       +7.50  -> -7.50
+
+-- Infinities
+cpnx011 copynegate  Infinity    -> -Infinity
+cpnx012 copynegate  -Infinity   -> Infinity
+
+-- NaNs, 0 payload
+cpnx021 copynegate         NaN  -> -NaN
+cpnx022 copynegate        -NaN  -> NaN
+cpnx023 copynegate        sNaN  -> -sNaN
+cpnx024 copynegate       -sNaN  -> sNaN
+
+-- NaNs, non-0 payload
+cpnx031 copynegate       NaN13  -> -NaN13
+cpnx032 copynegate      -NaN13  -> NaN13
+cpnx033 copynegate      sNaN13  -> -sNaN13
+cpnx034 copynegate     -sNaN13  -> sNaN13
+cpnx035 copynegate       NaN70  -> -NaN70
+cpnx036 copynegate      -NaN70  -> NaN70
+cpnx037 copynegate      sNaN101 -> -sNaN101
+cpnx038 copynegate     -sNaN101 -> sNaN101
+
+-- finites
+cpnx101 copynegate          7   -> -7
+cpnx102 copynegate         -7   -> 7
+cpnx103 copynegate         75   -> -75
+cpnx104 copynegate        -75   -> 75
+cpnx105 copynegate       7.50   -> -7.50
+cpnx106 copynegate      -7.50   -> 7.50
+cpnx107 copynegate       7.500  -> -7.500
+cpnx108 copynegate      -7.500  -> 7.500
+
+-- zeros
+cpnx111 copynegate          0   -> -0
+cpnx112 copynegate         -0   -> 0
+cpnx113 copynegate       0E+4   -> -0E+4
+cpnx114 copynegate      -0E+4   -> 0E+4
+cpnx115 copynegate     0.0000   -> -0.0000
+cpnx116 copynegate    -0.0000   -> 0.0000
+cpnx117 copynegate      0E-141  -> -0E-141
+cpnx118 copynegate     -0E-141  -> 0E-141
+
+-- full coefficients, alternating bits
+cpnx121 copynegate  268268268         -> -268268268
+cpnx122 copynegate  -268268268        -> 268268268
+cpnx123 copynegate  134134134         -> -134134134
+cpnx124 copynegate  -134134134        -> 134134134
+
+-- Nmax, Nmin, Ntiny
+cpnx131 copynegate  9.99999999E+999   -> -9.99999999E+999
+cpnx132 copynegate  1E-999                     -> -1E-999
+cpnx133 copynegate  1.00000000E-999   -> -1.00000000E-999
+cpnx134 copynegate  1E-1007                    -> -1E-1007
+
+cpnx135 copynegate  -1E-1007                   -> 1E-1007
+cpnx136 copynegate  -1.00000000E-999  -> 1.00000000E-999
+cpnx137 copynegate  -1E-999                    -> 1E-999
+cpnx138 copynegate  -9.99999999E+999  -> 9.99999999E+999

from_cpython/Lib/test/decimaltestdata/copysign.decTest

+------------------------------------------------------------------------
+-- copysign.decTest -- quiet copy with sign from rhs                  --
+-- Copyright (c) IBM Corporation, 1981, 2008.  All rights reserved.   --
+------------------------------------------------------------------------
+-- Please see the document "General Decimal Arithmetic Testcases"     --
+-- at http://www2.hursley.ibm.com/decimal for the description of      --
+-- these testcases.                                                   --
+--                                                                    --
+-- These testcases are experimental ('beta' versions), and they       --
+-- may contain errors.  They are offered on an as-is basis.  In       --
+-- particular, achieving the same results as the tests here is not    --
+-- a guarantee that an implementation complies with any Standard      --
+-- or specification.  The tests are not exhaustive.                   --
+--                                                                    --
+-- Please send comments, suggestions, and corrections to the author:  --
+--   Mike Cowlishaw, IBM Fellow                                       --
+--   IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK         --
+--   mfc@uk.ibm.com                                                   --
+------------------------------------------------------------------------
+version: 2.59
+
+extended:    1
+precision:   9
+rounding:    half_up
+maxExponent: 999
+minExponent: -999
+
+-- Sanity check, and examples from decArith
+cpsx001 copysign   +7.50       11  -> 7.50
+cpsx002 copysign   '1.50'   '7.33' -> 1.50
+cpsx003 copysign  '-1.50'   '7.33' -> 1.50
+cpsx004 copysign   '1.50'  '-7.33' -> -1.50
+cpsx005 copysign  '-1.50'  '-7.33' -> -1.50
+
+-- Infinities
+cpsx011 copysign  Infinity       11 -> Infinity
+cpsx012 copysign  -Infinity      11 -> Infinity
+
+-- NaNs, 0 payload
+cpsx021 copysign         NaN     11 -> NaN
+cpsx022 copysign        -NaN     11 -> NaN
+cpsx023 copysign        sNaN     11 -> sNaN
+cpsx024 copysign       -sNaN     11 -> sNaN
+
+-- NaNs, non-0 payload
+cpsx031 copysign       NaN10     11 -> NaN10
+cpsx032 copysign      -NaN10     11 -> NaN10
+cpsx033 copysign      sNaN10     11 -> sNaN10
+cpsx034 copysign     -sNaN10     11 -> sNaN10
+cpsx035 copysign       NaN7      11 -> NaN7
+cpsx036 copysign      -NaN7      11 -> NaN7
+cpsx037 copysign      sNaN101    11 -> sNaN101
+cpsx038 copysign     -sNaN101    11 -> sNaN101
+
+-- finites
+cpsx101 copysign          7      11 -> 7
+cpsx102 copysign         -7      11 -> 7
+cpsx103 copysign         75      11 -> 75
+cpsx104 copysign        -75      11 -> 75
+cpsx105 copysign       7.50      11 -> 7.50
+cpsx106 copysign      -7.50      11 -> 7.50
+cpsx107 copysign       7.500     11 -> 7.500
+cpsx108 copysign      -7.500     11 -> 7.500
+
+-- zeros
+cpsx111 copysign          0      11 -> 0
+cpsx112 copysign         -0      11 -> 0
+cpsx113 copysign       0E+4      11 -> 0E+4
+cpsx114 copysign      -0E+4      11 -> 0E+4
+cpsx115 copysign     0.0000      11 -> 0.0000
+cpsx116 copysign    -0.0000      11 -> 0.0000
+cpsx117 copysign      0E-141     11 -> 0E-141
+cpsx118 copysign     -0E-141     11 -> 0E-141
+
+-- full coefficients, alternating bits
+cpsx121 copysign   268268268           11 -> 268268268
+cpsx122 copysign  -268268268           11 -> 268268268
+cpsx123 copysign   134134134           11 -> 134134134
+cpsx124 copysign  -134134134           11 -> 134134134
+
+-- Nmax, Nmin, Ntiny
+cpsx131 copysign  9.99999999E+999      11 -> 9.99999999E+999
+cpsx132 copysign  1E-999               11 -> 1E-999
+cpsx133 copysign  1.00000000E-999      11 -> 1.00000000E-999
+cpsx134 copysign  1E-1007              11 -> 1E-1007
+
+cpsx135 copysign  -1E-1007             11 -> 1E-1007
+cpsx136 copysign  -1.00000000E-999     11 -> 1.00000000E-999
+cpsx137 copysign  -1E-999              11 -> 1E-999
+cpsx138 copysign  -9.99999999E+999     11 -> 9.99999999E+999
+
+-- repeat with negative RHS
+
+-- Infinities
+cpsx211 copysign  Infinity       -34 -> -Infinity
+cpsx212 copysign  -Infinity      -34 -> -Infinity
+
+-- NaNs, 0 payload
+cpsx221 copysign         NaN     -34 -> -NaN
+cpsx222 copysign        -NaN     -34 -> -NaN
+cpsx223 copysign        sNaN     -34 -> -sNaN
+cpsx224 copysign       -sNaN     -34 -> -sNaN
+
+-- NaNs, non-0 payload
+cpsx231 copysign       NaN10     -34 -> -NaN10
+cpsx232 copysign      -NaN10     -34 -> -NaN10
+cpsx233 copysign      sNaN10     -34 -> -sNaN10
+cpsx234 copysign     -sNaN10     -34 -> -sNaN10
+cpsx235 copysign       NaN7      -34 -> -NaN7
+cpsx236 copysign      -NaN7      -34 -> -NaN7
+cpsx237 copysign      sNaN101    -34 -> -sNaN101
+cpsx238 copysign     -sNaN101    -34 -> -sNaN101
+
+-- finites
+cpsx301 copysign          7      -34 -> -7
+cpsx302 copysign         -7      -34 -> -7
+cpsx303 copysign         75      -34 -> -75
+cpsx304 copysign        -75      -34 -> -75
+cpsx305 copysign       7.50      -34 -> -7.50
+cpsx306 copysign      -7.50      -34 -> -7.50
+cpsx307 copysign       7.500     -34 -> -7.500
+cpsx308 copysign      -7.500     -34 -> -7.500
+
+-- zeros
+cpsx311 copysign          0      -34 -> -0
+cpsx312 copysign         -0      -34 -> -0
+cpsx313 copysign       0E+4      -34 -> -0E+4
+cpsx314 copysign      -0E+4      -34 -> -0E+4
+cpsx315 copysign     0.0000      -34 -> -0.0000
+cpsx316 copysign    -0.0000      -34 -> -0.0000
+cpsx317 copysign      0E-141     -34 -> -0E-141
+cpsx318 copysign     -0E-141     -34 -> -0E-141
+
+-- full coefficients, alternating bits
+cpsx321 copysign   268268268          -18 -> -268268268
+cpsx322 copysign  -268268268          -18 -> -268268268
+cpsx323 copysign   134134134          -18 -> -134134134
+cpsx324 copysign  -134134134          -18 -> -134134134
+
+-- Nmax, Nmin, Ntiny
+cpsx331 copysign  9.99999999E+999     -18 -> -9.99999999E+999
+cpsx332 copysign  1E-999              -18 -> -1E-999
+cpsx333 copysign  1.00000000E-999     -18 -> -1.00000000E-999
+cpsx334 copysign  1E-1007             -18 -> -1E-1007
+
+cpsx335 copysign  -1E-1007            -18 -> -1E-1007
+cpsx336 copysign  -1.00000000E-999    -18 -> -1.00000000E-999
+cpsx337 copysign  -1E-999             -18 -> -1E-999
+cpsx338 copysign  -9.99999999E+999    -18 -> -9.99999999E+999
+
+-- Other kinds of RHS
+cpsx401 copysign          701    -34 -> -701
+cpsx402 copysign         -720    -34 -> -720
+cpsx403 copysign          701    -0  -> -701
+cpsx404 copysign         -720    -0  -> -720
+cpsx405 copysign          701    +0  ->  701
+cpsx406 copysign         -720    +0  ->  720
+cpsx407 copysign          701    +34 ->  701
+cpsx408 copysign         -720    +34 ->  720
+
+cpsx413 copysign          701    -Inf  -> -701
+cpsx414 copysign         -720    -Inf  -> -720
+cpsx415 copysign          701    +Inf  ->  701
+cpsx416 copysign         -720    +Inf  ->  720
+
+cpsx420 copysign          701    -NaN  -> -701
+cpsx421 copysign         -720    -NaN  -> -720
+cpsx422 copysign          701    +NaN  ->  701
+cpsx423 copysign         -720    +NaN  ->  720
+cpsx425 copysign         -720    +NaN8 ->  720
+
+cpsx426 copysign          701    -sNaN  -> -701
+cpsx427 copysign         -720    -sNaN  -> -720
+cpsx428 copysign          701    +sNaN  ->  701
+cpsx429 copysign         -720    +sNaN  ->  720
+cpsx430 copysign         -720    +sNaN3 ->  720
+

from_cpython/Lib/test/decimaltestdata/ddAbs.decTest

+------------------------------------------------------------------------
+-- ddAbs.decTest -- decDouble absolute value, heeding sNaN            --
+-- Copyright (c) IBM Corporation, 1981, 2008.  All rights reserved.   --
+------------------------------------------------------------------------
+-- Please see the document "General Decimal Arithmetic Testcases"     --
+-- at http://www2.hursley.ibm.com/decimal for the description of      --
+-- these testcases.                                                   --
+--                                                                    --
+-- These testcases are experimental ('beta' versions), and they       --
+-- may contain errors.  They are offered on an as-is basis.  In       --
+-- particular, achieving the same results as the tests here is not    --
+-- a guarantee that an implementation complies with any Standard      --
+-- or specification.  The tests are not exhaustive.                   --
+--                                                                    --
+-- Please send comments, suggestions, and corrections to the author:  --
+--   Mike Cowlishaw, IBM Fellow                                       --
+--   IBM UK, PO Box 31, Birmingham Road, Warwick CV34 5JL, UK         --
+--   mfc@uk.ibm.com                                                   --
+------------------------------------------------------------------------
+version: 2.59
+
+precision:   16
+maxExponent: 384
+minExponent: -383
+extended:    1
+clamp:       1
+rounding:    half_even
+
+ddabs001 abs '1'      -> '1'
+ddabs002 abs '-1'     -> '1'
+ddabs003 abs '1.00'   -> '1.00'
+ddabs004 abs '-1.00'  -> '1.00'
+ddabs005 abs '0'      -> '0'
+ddabs006 abs '0.00'   -> '0.00'
+ddabs007 abs '00.0'   -> '0.0'
+ddabs008 abs '00.00'  -> '0.00'
+ddabs009 abs '00'     -> '0'
+
+ddabs010 abs '-2'     -> '2'
+ddabs011 abs '2'      -> '2'
+ddabs012 abs '-2.00'  -> '2.00'
+ddabs013 abs '2.00'   -> '2.00'
+ddabs014 abs '-0'     -> '0'
+ddabs015 abs '-0.00'  -> '0.00'
+ddabs016 abs '-00.0'  -> '0.0'
+ddabs017 abs '-00.00' -> '0.00'
+ddabs018 abs '-00'    -> '0'
+
+ddabs020 abs '-2000000' -> '2000000'
+ddabs021 abs '2000000'  -> '2000000'
+
+ddabs030 abs '+0.1'            -> '0.1'
+ddabs031 abs '-0.1'            -> '0.1'
+ddabs032 abs '+0.01'           -> '0.01'
+ddabs033 abs '-0.01'           -> '0.01'
+ddabs034 abs '+0.001'          -> '0.001'
+ddabs035 abs '-0.001'          -> '0.001'
+ddabs036 abs '+0.000001'       -> '0.000001'
+ddabs037 abs '-0.000001'       -> '0.000001'
+ddabs038 abs '+0.000000000001' -> '1E-12'
+ddabs039 abs '-0.000000000001' -> '1E-12'
+
+-- examples from decArith
+ddabs040 abs '2.1'     ->  '2.1'
+ddabs041 abs '-100'    ->  '100'
+ddabs042 abs '101.5'   ->  '101.5'
+ddabs043 abs '-101.5'  ->  '101.5'
+
+-- more fixed, potential LHS swaps/overlays if done by subtract 0
+ddabs060 abs '-56267E-10'  -> '0.0000056267'
+ddabs061 abs '-56267E-5'   -> '0.56267'
+ddabs062 abs '-56267E-2'   -> '562.67'
+ddabs063 abs '-56267E-1'   -> '5626.7'
+ddabs065 abs '-56267E-0'   -> '56267'
+
+-- subnormals and underflow
+
+-- long operand tests
+ddabs321 abs 1234567890123456  -> 1234567890123456
+ddabs322 abs 12345678000  -> 12345678000
+ddabs323 abs 1234567800   -> 1234567800
+ddabs324 abs 1234567890   -> 1234567890
+ddabs325 abs 1234567891   -> 1234567891
+ddabs326 abs 12345678901  -> 12345678901
+ddabs327 abs 1234567896   -> 1234567896
+
+-- zeros
+ddabs111 abs          0   -> 0
+ddabs112 abs         -0   -> 0
+ddabs113 abs       0E+6   -> 0E+6
+ddabs114 abs      -0E+6   -> 0E+6
+ddabs115 abs     0.0000   -> 0.0000
+ddabs116 abs    -0.0000   -> 0.0000
+ddabs117 abs      0E-141  -> 0E-141
+ddabs118 abs     -0E-141  -> 0E-141
+
+-- full coefficients, alternating bits
+ddabs121 abs  2682682682682682         -> 2682682682682682
+ddabs122 abs  -2682682682682682        -> 2682682682682682
+ddabs123 abs  1341341341341341         -> 1341341341341341
+ddabs124 abs  -1341341341341341        -> 1341341341341341
+
+-- Nmax, Nmin, Ntiny
+ddabs131 abs  9.999999999999999E+384   -> 9.999999999999999E+384
+ddabs132 abs  1E-383                   -> 1E-383
+ddabs133 abs  1.000000000000000E-383   -> 1.000000000000000E-383
+ddabs134 abs  1E-398                   -> 1E-398 Subnormal
+
+ddabs135 abs  -1E-398                  -> 1E-398 Subnormal
+ddabs136 abs  -1.000000000000000E-383  -> 1.000000000000000E-383
+ddabs137 abs  -1E-383                  -> 1E-383
+ddabs138 abs  -9.999999999999999E+384  -> 9.999999999999999E+384
+
+-- specials
+ddabs520 abs 'Inf'    -> 'Infinity'
+ddabs521 abs '-Inf'   -> 'Infinity'
+ddabs522 abs   NaN    ->  NaN
+ddabs523 abs  sNaN    ->  NaN   Invalid_operation
+ddabs524 abs   NaN22  ->  NaN22
+ddabs525 abs  sNaN33  ->  NaN33 Invalid_operation
+ddabs526 abs  -NaN22  -> -NaN22
+ddabs527 abs -sNaN33  -> -NaN33 Invalid_operation
+
+-- Null tests
+ddabs900 abs  # -> NaN Invalid_operation
+