diff --git a/Lib/sunau.py b/Lib/sunau.py
--- a/Lib/sunau.py
+++ b/Lib/sunau.py
@@ -233,7 +233,7 @@
         if self._data_size == AUDIO_UNKNOWN_SIZE:
             return AUDIO_UNKNOWN_SIZE
         if self._encoding in _simple_encodings:
-            return self._data_size / self._framesize
+            return self._data_size // self._framesize
         return 0                # XXX--must do some arithmetic here
 
     def getcomptype(self):
@@ -268,7 +268,8 @@
             if nframes == AUDIO_UNKNOWN_SIZE:
                 data = self._file.read()
             else:
-                data = self._file.read(nframes * self._framesize * self._nchannels)
+                data = self._file.read(nframes * self._framesize)
+            self._soundpos += len(data) // self._framesize
             if self._encoding == AUDIO_FILE_ENCODING_MULAW_8:
                 import audioop
                 data = audioop.ulaw2lin(data, self._sampwidth)
@@ -407,10 +408,10 @@
 
     def writeframesraw(self, data):
         self._ensure_header_written()
-        nframes = len(data) / self._framesize
         if self._comptype == 'ULAW':
             import audioop
             data = audioop.lin2ulaw(data, self._sampwidth)
+        nframes = len(data) / self._framesize
         self._file.write(data)
         self._nframeswritten = self._nframeswritten + nframes
         self._datawritten = self._datawritten + len(data)
@@ -475,6 +476,10 @@
             length = AUDIO_UNKNOWN_SIZE
         else:
             length = self._nframes * self._framesize
+        try:
+            self._form_length_pos = self._file.tell()
+        except (AttributeError, OSError):
+            self._form_length_pos = None
         _write_u32(self._file, length)
         self._datalength = length
         _write_u32(self._file, encoding)
@@ -484,7 +489,7 @@
         self._file.write(b'\0'*(header_size - len(self._info) - 24))
 
     def _patchheader(self):
-        self._file.seek(8)
+        self._file.seek(self._form_length_pos)
         _write_u32(self._file, self._datawritten)
         self._datalength = self._datawritten
         self._file.seek(0, 2)
diff --git a/Lib/test/audiodata/alaw.aifc b/Lib/test/audiodata/alaw.aifc
new file mode 100644
index 0000000000000000000000000000000000000000..462e9420f8f3000ea52a6db15a9e4e4b66ed29bc
GIT binary patch
literal 176
zc${<d5AtPTU|8Yk>E`Sf<{AWKvn*-|ba3|f1&J##Fab#e1_1}Y-3<(2keHKL&f(~j
zSgv4XWyla5?B@a$%wT|mt5+vYYHHfDW%K5J`*!VGvSit^g$oxfSPTXW7A#!2Y}t|}
zOPB83w|VoHElo|6CSAQMB*esIVq$D;XJ=)lqN1jzsHmWz3<e4cii&D#Dk@f1c6P?b
KCMHZwLP7w@z&0KL

diff --git a/Lib/test/audiodata/pcm16.aiff b/Lib/test/audiodata/pcm16.aiff
new file mode 100644
index 0000000000000000000000000000000000000000..fa03513b80b4d4219db86b3a6e3a3d673f4c5c90
GIT binary patch
literal 246
zc${<d5AtPTV0h=~>E`C_?+aoJF)#s10|o&HzTFKBU=SSa=K`coFdzZ$3)~mPbH#I&
z7Aq~*b<}k<mo%5O|8M`_{ha$bza+n;;CaFG!gIoNBKJh@iE4^!0?{BoNE{>&Qs=<n
zzyQ(*(ho8RWFE*|kojK>z8Jii{9^Lm*t@Zp_Fvk6;`xc^2N(}9?l9V6v~k|Xd25o^
qB(0dTV#+d?WiCtWmezr25FaECk_V|fz;J*8qz|MYWDdwYkhuV}9%2>%

diff --git a/Lib/test/audiodata/pcm16.au b/Lib/test/audiodata/pcm16.au
new file mode 100644
index 0000000000000000000000000000000000000000..a9d1e280b7d1ec8051b5477924d0a5e525d6b16f
GIT binary patch
literal 224
zc%0KK&P!onU{C<!13=8oz_7akNHZ}Y0qzUj7sPYLbCnh=E!K6^bu^bWm$d(H|KI(b
z`#HZPzog)K!Slj%!gC_`MDB@difRJUAU;SOBo9*Oz~I0D(g)HHG6!TH$Xt;5Uktt&
zyqNrA^4-|Gv6uE=+JEBtiRT9x4>0a9+F`VD-o|-rlGY@xn6hHZGM8m8OY4@_foKpP
XBo2}XsXG94K1d%(Kgb-Ac_4EEZU9|q

diff --git a/Lib/test/audiodata/pcm16.wav b/Lib/test/audiodata/pcm16.wav
new file mode 100644
index 0000000000000000000000000000000000000000..fce61ea41a1bd21a7d527711b049f633f0ad00cf
GIT binary patch
literal 236
zc$^FJbaQ*cz`zjh80MOmTcRKUWHT}_F*NK3GTt#UurLTPq$HLk9$<ig3)~mDbH#JT
z7b`7Ra@2Lyl{A+$|8M`_{+#<c_awh0zj?v)f^))i!uLe(iEN5$iUQFfK1duS4^qeA
zz~BJV2htBR2V@?|T#)$&UktuXelht)?A_SA`!DUk^!&v06O0EK4;bw*+A(kAyp2g~
rlGaRFF=d6zGM8m_OY4?`Xb>MH4w46{V>rNY0HhD3A7l>5Jdn8nO0Huj

diff --git a/Lib/test/audiodata/pcm24.aiff b/Lib/test/audiodata/pcm24.aiff
new file mode 100644
index 0000000000000000000000000000000000000000..cb8559c404cd71ea4c7cbab222ed8fe920e73eb1
GIT binary patch
literal 342
zc$`(vF$)1<7zgm@jIIn8tR{;vF{pE$PLxw_5G67D0tO|E4{$R@k-=h-kSK#mvRmZ?
zU_Jl*CvU&rp5FfN^E_s$Toh3(J#U&usfb$q;=vu4V8*xY$?w><l|?Ede@DI6Akh9m
zc=Cp*o`z(o0GjJU?$Q9Ol>&RTflB)g)tv^leg|0dof+o&HzNY<$^M+hx!i&KykawW
zI$pTfRk-a>aDJ@dAPTG#V^|K)uxOevcT|`eN0@d8z?$#OFwegS5nxaD=Pb_U4qvp2
BjI;m%

diff --git a/Lib/test/audiodata/pcm24.wav b/Lib/test/audiodata/pcm24.wav
new file mode 100644
index 0000000000000000000000000000000000000000..3cfcaf884209e479d13703e40088d2736ccbfb65
GIT binary patch
literal 332
zc$_89F$+Oq6b9gPC4;-zu*oi&7!<-4gMo6Rq$^C<W-%yP{D3=C6d5cQ35hb8B)e69
z09M|5zn<ZAdcSi{A**RAMMO`O(yeyK=MoV`Y|`JMXxhag9%&dI!-ouC<)*^dbi-%r
zhiD=IId2$#zZlf68Hm*LupJlSW9kswm!UhT0BiP{VV-|Q;=q}l&t2Th8+gw=_y(u-
z0=4>p^WhHb=LHlw!X&hT%V-6fu>{pxz$rP0VQ&Vk*=L4%{uMa_XL3GwaW8N90~x!G
AKL7v#

diff --git a/Lib/test/audiodata/pcm32.aiff b/Lib/test/audiodata/pcm32.aiff
new file mode 100644
index 0000000000000000000000000000000000000000..9265f32486ffb336246202a1cb74f1849d908c53
GIT binary patch
literal 438
zc${<d5AtPTU|i?u>E`C_?+auz2r)1LNdpE22fp163}6r(?B@bh)xm%UxGzLa2VwD?
zuNOgBY0;POAgt?Xa~6cnCB5c>u>Jr4|3TROT>M%P_Diw|0O8<yyIepxJm>2L5RTkq
zKNW<dnkr|4FpLkAhpC6@hneR9bPEW>?1R}4a}UgYF!#dT|3!akCJ4Wn%%u;)cVoFZ
zLHN?X!^R+d;@Q?D5Iz9(JP7YFTo4Sx8|NP10K#h$UH5?Sipg9CAiT`^KsE?3t!+yO
fVHh7K4^t1*4>J#FHUkL5?1R}4a}UgYF!urgvVFNw

diff --git a/Lib/test/audiodata/pcm32.au b/Lib/test/audiodata/pcm32.au
new file mode 100644
index 0000000000000000000000000000000000000000..f0436c7af0fd95e5a4bd4f485b1ef89bcad41889
GIT binary patch
literal 416
zc%0KK&P!onU{GLSU~B-=tPBjhK{OKs8sNSVH64V-bG}{#VWmZ1zJsu?qs>_mHkb68
z2g3IM|NjSJ_jB=ULD(<JA^?Pg=k0O<;qaWV7eF|2kNs2-j%uo$3BoWwOdh5lrXOaW
z1JErX46_erKg>Na_rcr?bN?6prI{f7VltOL2;Yt6<^<tO`wkm}@QG(zlR)?YFd#s9
zhv9-?5Z*ZV_y!POljyn!gjY=FG63Oa&IhtVcxi20Itat~FnO4In0}afK(iS@7-k>L
Mewce;?t{4(06Rdm(*OVf

diff --git a/Lib/test/audiodata/pcm32.wav b/Lib/test/audiodata/pcm32.wav
new file mode 100644
index 0000000000000000000000000000000000000000..e73fd5dc7e568632c6f6b9ff5db542baee4fb828
GIT binary patch
literal 428
zc$^FJbaPw6$iNWp80MOmTcRMqz`(%Bz{Jq78_2lB%D};(z>tzylGp%L0|V2eE^veJ
z#jiQyApHHyA|(($YvZU3!t=Z&%|ZD8|Nr(Nyf*%vI|v6@B>91`%dUCBAbjC#PB;ip
zwcis7!ZRzIqCgnNhsnd#!}P<<13JY4gkko<?1#Ar=02EvVeZdds{aLq^|>a$0AWt<
z*t;NXe0bj_5Kh|q>;wn{y?g+KgBKX?0O1YC=WYbyJ+6ssK-hq5@(K{nKH$6zgwxw<
hmx3^i50i(fhv|oz2Xx8-5Qf<YvmfRjnEPPv1posex>W!G

diff --git a/Lib/test/audiodata/pcm8.aiff b/Lib/test/audiodata/pcm8.aiff
new file mode 100644
index 0000000000000000000000000000000000000000..1bb5536528f3e4aa8ac1775adec747a25bbc22da
GIT binary patch
literal 150
zc${<d5AtPTVCZx7baQj|_XV+q7?^;h0Rx8v-|hwmFbEFza{*Er3~<21BQCC_q^oOg
zZg21I?&lXA93CDS85I>786FN)?dR_9;9zd9tE;3WF3!Wl!0_eE%a`}=UA}zs<iUeG
qcW&CWcJ0cQ%a<=(wtV@@m21~-+O%`$fdeN`UcP+q-piL?z5oCP<TZK#

diff --git a/Lib/test/audiodata/pcm8.au b/Lib/test/audiodata/pcm8.au
new file mode 100644
index 0000000000000000000000000000000000000000..46bafaf2e054cc469ac1b1c3c36e9f0c650b859e
GIT binary patch
literal 128
zc$_uGAr62b7(n5FW;)f;u@be>C<F${V77PxPa`8xXw0IKOsCU1fNsvWeS5>UE&$NK
z=2r)B?%)3q!k7?B85>8=g^*Gyt&P!IDJg~Ee3}@eln{&&0%)z)QgTk|zGDo*d*`e@
T4r`tBK7<&rE2W%EskOBSwwy6D

diff --git a/Lib/test/audiodata/pcm8.wav b/Lib/test/audiodata/pcm8.wav
new file mode 100644
index 0000000000000000000000000000000000000000..9772082e7a1aca91249f6991ee48058545e2466c
GIT binary patch
literal 140
zc$^i-p$-Be002-l8T|y)F#?4~JA$`SWz)vI&AAb5Y*vDiPN$OzhPy_i5E%D0Vtenx
zr|AO#xUuW``O>Fj_YUlV`F6bjI)KNl=X<X));i~X2r({8N;#KOYirxqTCJtzoYK0+
o7=riCS!;~eN=YdM=ZsNG2*wCOI1CUXgfStMjw9znNU4<8Kj@w~5C8xG

diff --git a/Lib/test/audiodata/ulaw.aifc b/Lib/test/audiodata/ulaw.aifc
new file mode 100644
index 0000000000000000000000000000000000000000..3799c21d2c6ba7deee3f9f875af836d749e562bb
GIT binary patch
literal 176
zc${<d5AtPTU|8Yk>E`Sf<{AWKvn*-|ba3|f1&J##Fab#e1_1}Y-3<(2P@0oi&au@e
zv0TB(%8(&A*v|zhn85%A|Nn2_zGB6^c{68DnbP0i+uPIA1q7X70Als@^!E1mPnj}v
z=Dc|;R&3w?|G&AphK8J+q@;)lKR+)o4-Xd*aDoAd#lyqP%g-+&A}J{+r=ekP4ge;X
BF@OL7

diff --git a/Lib/test/audiodata/ulaw.au b/Lib/test/audiodata/ulaw.au
new file mode 100644
index 0000000000000000000000000000000000000000..6b3454484e3ee3420d4ac32670475ea3780a7904
GIT binary patch
literal 128
zc$_W9p$>o`6ouidO$Vb;D9lK*-q$ghExv$N2cu9ZWZr<_!{LSbZU4?$&tnIGh1#eA
z;Js)^_|;lU&MCzhg7?l@`;fb9&syia4<W{saxSG-L}Rp8N=hL(XKW@@*B)b>3n8Ua
IS{sA-0d5Q>$^ZZW

diff --git a/Lib/test/audiotests.py b/Lib/test/audiotests.py
new file mode 100644
--- /dev/null
+++ b/Lib/test/audiotests.py
@@ -0,0 +1,283 @@
+from test.support import findfile, TESTFN, unlink
+import unittest
+import array
+import io
+import pickle
+import sys
+
+class UnseekableIO(io.FileIO):
+    def tell(self):
+        raise io.UnsupportedOperation
+
+    def seek(self, *args, **kwargs):
+        raise io.UnsupportedOperation
+
+    def close(self):
+        pass
+
+def byteswap2(data):
+    a = array.array('h', data)
+    a.byteswap()
+    return a.tobytes()
+
+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', data)
+    a.byteswap()
+    return a.tobytes()
+
+
+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))
+        self.assertEqual(params.nchannels, nchannels)
+        self.assertEqual(params.sampwidth, sampwidth)
+        self.assertEqual(params.framerate, framerate)
+        self.assertEqual(params.nframes, nframes)
+        self.assertEqual(params.comptype, comptype)
+        self.assertEqual(params.compname, 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):
+        with self.module.open(testfile, 'rb') as f:
+            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)
+
+    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_context_manager_calls_close(self):
+        # Close checks for a minimum header and will raise an error
+        # if it is not set, so this proves that close is called.
+        with self.assertRaises(self.module.Error):
+            with self.module.open(TESTFN, 'wb'):
+                pass
+        with self.assertRaises(self.module.Error):
+            with open(TESTFN, 'wb') as testfile:
+                with self.module.open(testfile):
+                    pass
+
+    def test_context_manager_with_open_file(self):
+        with open(TESTFN, 'wb') as testfile:
+            with self.module.open(testfile) as f:
+                f.setnchannels(self.nchannels)
+                f.setsampwidth(self.sampwidth)
+                f.setframerate(self.framerate)
+                f.setcomptype(self.comptype, self.compname)
+            self.assertEqual(testfile.closed, self.close_fd)
+        with open(TESTFN, 'rb') as testfile:
+            with self.module.open(testfile) as f:
+                self.assertFalse(f.getfp().closed)
+                params = f.getparams()
+                self.assertEqual(params.nchannels, self.nchannels)
+                self.assertEqual(params.sampwidth, self.sampwidth)
+                self.assertEqual(params.framerate, self.framerate)
+            if not self.close_fd:
+                self.assertIsNone(f.getfp())
+            self.assertEqual(testfile.closed, self.close_fd)
+
+    def test_context_manager_with_filename(self):
+        # If the file doesn't get closed, this test won't fail, but it will
+        # produce a resource leak warning.
+        with self.module.open(TESTFN, 'wb') as f:
+            f.setnchannels(self.nchannels)
+            f.setsampwidth(self.sampwidth)
+            f.setframerate(self.framerate)
+            f.setcomptype(self.comptype, self.compname)
+        with self.module.open(TESTFN) as f:
+            self.assertFalse(f.getfp().closed)
+            params = f.getparams()
+            self.assertEqual(params.nchannels, self.nchannels)
+            self.assertEqual(params.sampwidth, self.sampwidth)
+            self.assertEqual(params.framerate, self.framerate)
+        if not self.close_fd:
+            self.assertIsNone(f.getfp())
+
+    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)
+
+
+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):
+        testfile = open(self.sndfilepath, 'rb')
+        f = self.f = self.module.open(testfile)
+        self.assertFalse(testfile.closed)
+        f.close()
+        self.assertEqual(testfile.closed, self.close_fd)
+        testfile = open(TESTFN, 'wb')
+        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 chunks(seq, size):
+    for i in range(0, len(seq), size):
+        yield seq[i: i + size]
+
+def printhex(framesize, frames):
+    linesize = 32 // framesize * framesize
+    for line in chunks(frames, linesize):
+        sline = ''.join('%02X' % b for b in line)
+        print("    '%s'\\" % ' '.join(chunks(sline, 2 * framesize)))
+
+def unpack(width, data, byteorder):
+    return [int.from_bytes(data[i: i + width], byteorder, signed=True)
+            for i in range(0, len(data), width)]
+
+def drawsound(nchannels,  sampwidth, frames, byteorder):
+    import sys
+    d = unpack(sampwidth, frames, byteorder)
+    w = 50
+    for i, x in enumerate(d[::2]):
+        #x = x & 0xffff
+        print('%8d' % (i,), end=' ')
+        if x < 0:
+            print('%*s%*s %8d' % (w, '*' * (w * -x // 2**15), w, '', x))
+        else:
+            print('%*s%-*s %8d' % (w, '', w, '#' * (w * x // 2**15), x))
diff --git a/Lib/test/test_aifc.py b/Lib/test/test_aifc.py
--- a/Lib/test/test_aifc.py
+++ b/Lib/test/test_aifc.py
@@ -1,57 +1,162 @@
-from test.support import findfile, run_unittest, TESTFN, unlink
+from test.support import findfile, TESTFN, unlink
 import unittest
+from test import audiotests
 import os
 import io
+import sys
 import struct
-import pickle
-
 import aifc
 
 
-class AIFCTest(unittest.TestCase):
+class AifcPCM8Test(audiotests.AudioWriteTests,
+                   audiotests.AudioTestsWithSourceFile,
+                   unittest.TestCase):
+    module = aifc
+    sndfilename = 'pcm8.aiff'
+    sndfilenframes = 48
+    nchannels = 2
+    sampwidth = 1
+    framerate = 48000
+    nframes = 48
+    comptype = b'NONE'
+    compname = b'not compressed'
+    frames = bytes.fromhex(
+    '0000 0C0C 1717 2222 2D2D 3737 3F3F 4747 4E4E 5353 5757 5959 5A5A 5959'\
+    '5757 5353 4E4E 4747 4040 3737 2D2D 2222 1717 0C0C 0000 F4F4 E9E9 DEDE'\
+    'D3D3 C9C9 C1C1 B9B9 B2B2 ADAD A9A9 A7A7 A6A6 A7A7 A9A9 ADAD B2B2 B9B9'\
+    'C0C0 C9C9 D3D3 DEDE E9E9 F4F4')
+    close_fd = True
 
-    def setUp(self):
-        self.f = self.fout = None
-        self.sndfilepath = findfile('Sine-1000Hz-300ms.aif')
 
-    def tearDown(self):
-        if self.f is not None:
-            self.f.close()
-        if self.fout is not None:
-            try:
-                self.fout.close()
-            except (aifc.Error, AttributeError):
-                pass
-        unlink(TESTFN)
-        unlink(TESTFN + '.aiff')
+class AifcPCM16Test(audiotests.AudioWriteTests,
+                    audiotests.AudioTestsWithSourceFile,
+                    unittest.TestCase):
+    module = aifc
+    sndfilename = 'pcm16.aiff'
+    sndfilenframes = 48
+    nchannels = 2
+    sampwidth = 2
+    framerate = 48000
+    nframes = 48
+    comptype = b'NONE'
+    compname = b'not compressed'
+    frames = bytes.fromhex(
+    '00000000 0BD00BD0 176D176D 22A322A3 2D412D41 37193719 3FFF3FFF 47CE47CE'\
+    '4E624E62 539E539E 576C576C 59BC59BC 5A825A82 59BC59BC 576C576C 539E539E'\
+    '4E624E62 47CE47CE 40004000 37193719 2D412D41 22A322A3 176D176D 0BD00BD0'\
+    '00000000 F430F430 E893E893 DD5DDD5D D2BFD2BF C8E7C8E7 C001C001 B832B832'\
+    'B19EB19E AC62AC62 A894A894 A644A644 A57EA57E A644A644 A894A894 AC62AC62'\
+    'B19EB19E B832B832 C000C000 C8E7C8E7 D2BFD2BF DD5DDD5D E893E893 F430F430')
+    close_fd = True
 
+
+class AifcPCM24Test(audiotests.AudioWriteTests,
+                    audiotests.AudioTestsWithSourceFile,
+                    unittest.TestCase):
+    module = aifc
+    sndfilename = 'pcm24.aiff'
+    sndfilenframes = 48
+    nchannels = 2
+    sampwidth = 3
+    framerate = 48000
+    nframes = 48
+    comptype = b'NONE'
+    compname = b'not compressed'
+    frames = bytes.fromhex(
+    '000000000000 0BD05A0BD05A 176CF6176CF6 22A2F522A2F5 2D413C2D413C'\
+    '37194A37194A 3FFFFF3FFFFF 47CE5F47CE5F 4E62384E6238 539EBA539EBA'\
+    '576CF5576CF5 59BC3F59BC3F 5A82795A8279 59BC3F59BC3F 576CF5576CF5'\
+    '539EBA539EBA 4E62384E6238 47CE5F47CE5F 400000400000 37194A37194A'\
+    '2D413C2D413C 22A2F522A2F5 176CF6176CF6 0BD05A0BD05A 000000000000'\
+    'F42FA6F42FA6 E8930AE8930A DD5D0BDD5D0B D2BEC4D2BEC4 C8E6B6C8E6B6'\
+    'C00001C00001 B831A1B831A1 B19DC8B19DC8 AC6146AC6146 A8930BA8930B'\
+    'A643C1A643C1 A57D87A57D87 A643C1A643C1 A8930BA8930B AC6146AC6146'\
+    'B19DC8B19DC8 B831A1B831A1 C00000C00000 C8E6B6C8E6B6 D2BEC4D2BEC4'\
+    'DD5D0BDD5D0B E8930AE8930A F42FA6F42FA6')
+    close_fd = True
+
+
+class AifcPCM32Test(audiotests.AudioWriteTests,
+                    audiotests.AudioTestsWithSourceFile,
+                    unittest.TestCase):
+    module = aifc
+    sndfilename = 'pcm32.aiff'
+    sndfilenframes = 48
+    nchannels = 2
+    sampwidth = 4
+    framerate = 48000
+    nframes = 48
+    comptype = b'NONE'
+    compname = b'not compressed'
+    frames = bytes.fromhex(
+    '0000000000000000 0BD05A970BD05A97 176CF5D1176CF5D1 22A2F4F722A2F4F7'\
+    '2D413CCD2D413CCD 37194A9E37194A9E 3FFFFFFF3FFFFFFF 47CE5FAD47CE5FAD'\
+    '4E6238504E623850 539EBA44539EBA44 576CF5D0576CF5D0 59BC3F9559BC3F95'\
+    '5A8279995A827999 59BC3F9559BC3F95 576CF5D0576CF5D0 539EBA44539EBA44'\
+    '4E6238504E623850 47CE5FAD47CE5FAD 4000000040000000 37194A9E37194A9E'\
+    '2D413CCD2D413CCD 22A2F4F722A2F4F7 176CF5D1176CF5D1 0BD05A970BD05A97'\
+    '0000000000000000 F42FA569F42FA569 E8930A2FE8930A2F DD5D0B09DD5D0B09'\
+    'D2BEC333D2BEC333 C8E6B562C8E6B562 C0000001C0000001 B831A053B831A053'\
+    'B19DC7B0B19DC7B0 AC6145BCAC6145BC A8930A30A8930A30 A643C06BA643C06B'\
+    'A57D8667A57D8667 A643C06BA643C06B A8930A30A8930A30 AC6145BCAC6145BC'\
+    'B19DC7B0B19DC7B0 B831A053B831A053 C0000000C0000000 C8E6B562C8E6B562'\
+    'D2BEC333D2BEC333 DD5D0B09DD5D0B09 E8930A2FE8930A2F F42FA569F42FA569')
+    close_fd = True
+
+
+class AifcALAWTest(audiotests.AudioWriteTests,
+                   audiotests.AudioTestsWithSourceFile,
+                   unittest.TestCase):
+    module = aifc
+    sndfilename = 'alaw.aifc'
+    sndfilenframes = 48
+    nchannels = 2
+    sampwidth = 2
+    framerate = 48000
+    nframes = 48
+    comptype = b'alaw'
+    compname = b'ALaw 2:1'
+    frames = bytes.fromhex(
+    '00080008 0BC00BC0 17801780 23002300 2D002D00 37003700 3F003F00 46004600'\
+    '4E004E00 52005200 56005600 5A005A00 5A005A00 5A005A00 56005600 52005200'\
+    '4E004E00 46004600 42004200 37003700 2D002D00 23002300 17801780 0BC00BC0'\
+    '00080008 F440F440 E880E880 DD00DD00 D300D300 C900C900 C100C100 BA00BA00'\
+    'B200B200 AE00AE00 AA00AA00 A600A600 A600A600 A600A600 AA00AA00 AE00AE00'\
+    'B200B200 BA00BA00 C100C100 C900C900 D300D300 DD00DD00 E880E880 F440F440')
+    if sys.byteorder != 'big':
+        frames = audiotests.byteswap2(frames)
+    close_fd = True
+
+
+class AifcULAWTest(audiotests.AudioWriteTests,
+                   audiotests.AudioTestsWithSourceFile,
+                   unittest.TestCase):
+    module = aifc
+    sndfilename = 'ulaw.aifc'
+    sndfilenframes = 48
+    nchannels = 2
+    sampwidth = 2
+    framerate = 48000
+    nframes = 48
+    comptype = b'ulaw'
+    compname = b'\xb5Law 2:1'
+    frames = bytes.fromhex(
+    '00000000 0BBC0BBC 16FC16FC 227C227C 2C7C2C7C 367C367C 417C417C 497C497C'\
+    '4D7C4D7C 557C557C 557C557C 597C597C 597C597C 597C597C 557C557C 557C557C'\
+    '4D7C4D7C 497C497C 417C417C 367C367C 2C7C2C7C 227C227C 16FC16FC 0BBC0BBC'\
+    '00000000 F444F444 E904E904 DD84DD84 D384D384 C984C984 BE84BE84 B684B684'\
+    'B284B284 AA84AA84 AA84AA84 A684A684 A684A684 A684A684 AA84AA84 AA84AA84'\
+    'B284B284 B684B684 BE84BE84 C984C984 D384D384 DD84DD84 E904E904 F444F444')
+    if sys.byteorder != 'big':
+        frames = audiotests.byteswap2(frames)
+    close_fd = True
+
+
+class AifcMiscTest(audiotests.AudioTests, unittest.TestCase):
     def test_skipunknown(self):
         #Issue 2245
         #This file contains chunk types aifc doesn't recognize.
-        self.f = aifc.open(self.sndfilepath)
-
-    def test_params(self):
-        f = self.f = aifc.open(self.sndfilepath)
-        params = f.getparams()
-        self.assertEqual(f.getfp().name, self.sndfilepath)
-        self.assertEqual(f.getnchannels(), 2)
-        self.assertEqual(f.getsampwidth(), 2)
-        self.assertEqual(f.getframerate(), 48000)
-        self.assertEqual(f.getnframes(), 14400)
-        self.assertEqual(f.getcomptype(), b'NONE')
-        self.assertEqual(f.getcompname(), b'not compressed')
-        self.assertEqual(
-            f.getparams(),
-            (2, 2, 48000, 14400, b'NONE', b'not compressed'),
-            )
-
-        params = f.getparams()
-        self.assertEqual(params.nchannels, 2)
-        self.assertEqual(params.sampwidth, 2)
-        self.assertEqual(params.framerate, 48000)
-        self.assertEqual(params.nframes, 14400)
-        self.assertEqual(params.comptype, b'NONE')
-        self.assertEqual(params.compname, b'not compressed')
+        self.f = aifc.open(findfile('Sine-1000Hz-300ms.aif'))
 
     def test_params_added(self):
         f = self.f = aifc.open(TESTFN, 'wb')
@@ -68,102 +173,6 @@
         self.assertEqual(params.comptype, f.getcomptype())
         self.assertEqual(params.compname, f.getcompname())
 
-    def test_getparams_picklable(self):
-        self.f = aifc.open(self.sndfilepath)
-        params = self.f.getparams()
-        dump = pickle.dumps(params)
-        self.assertEqual(pickle.loads(dump), params)
-        self.f.close()
-
-    def test_context_manager(self):
-        with open(self.sndfilepath, 'rb') as testfile:
-            with aifc.open(testfile) as f:
-                pass
-            self.assertEqual(testfile.closed, True)
-        with open(TESTFN, 'wb') as testfile:
-            with self.assertRaises(aifc.Error):
-                with aifc.open(testfile, 'wb') as fout:
-                    pass
-            self.assertEqual(testfile.closed, True)
-            fout.close() # do nothing
-
-    def test_read(self):
-        f = self.f = aifc.open(self.sndfilepath)
-        self.assertEqual(f.readframes(0), b'')
-        self.assertEqual(f.tell(), 0)
-        self.assertEqual(f.readframes(2), b'\x00\x00\x00\x00\x0b\xd4\x0b\xd4')
-        f.rewind()
-        pos0 = f.tell()
-        self.assertEqual(pos0, 0)
-        self.assertEqual(f.readframes(2), b'\x00\x00\x00\x00\x0b\xd4\x0b\xd4')
-        pos2 = f.tell()
-        self.assertEqual(pos2, 2)
-        self.assertEqual(f.readframes(2), b'\x17t\x17t"\xad"\xad')
-        f.setpos(pos2)
-        self.assertEqual(f.readframes(2), b'\x17t\x17t"\xad"\xad')
-        f.setpos(pos0)
-        self.assertEqual(f.readframes(2), b'\x00\x00\x00\x00\x0b\xd4\x0b\xd4')
-        with self.assertRaises(aifc.Error):
-            f.setpos(-1)
-        with self.assertRaises(aifc.Error):
-            f.setpos(f.getnframes() + 1)
-
-    def test_write(self):
-        f = self.f = aifc.open(self.sndfilepath)
-        fout = self.fout = aifc.open(TESTFN, 'wb')
-        fout.aifc()
-        fout.setparams(f.getparams())
-        for frame in range(f.getnframes()):
-            fout.writeframes(f.readframes(1))
-        fout.close()
-        fout = self.fout = aifc.open(TESTFN, 'rb')
-        f.rewind()
-        self.assertEqual(f.getparams(), fout.getparams())
-        self.assertEqual(f.readframes(5), fout.readframes(5))
-
-    def test_compress(self):
-        f = self.f = aifc.open(self.sndfilepath)
-        fout = self.fout = aifc.open(TESTFN, 'wb')
-        fout.aifc()
-        fout.setnchannels(f.getnchannels())
-        fout.setsampwidth(f.getsampwidth())
-        fout.setframerate(f.getframerate())
-        fout.setcomptype(b'ULAW', b'foo')
-        for frame in range(f.getnframes()):
-            fout.writeframes(f.readframes(1))
-        fout.close()
-        self.assertLess(
-            os.stat(TESTFN).st_size,
-            os.stat(self.sndfilepath).st_size*0.75,
-            )
-        fout = self.fout = aifc.open(TESTFN, 'rb')
-        f.rewind()
-        self.assertEqual(f.getparams()[0:3], fout.getparams()[0:3])
-        self.assertEqual(fout.getcomptype(), b'ULAW')
-        self.assertEqual(fout.getcompname(), b'foo')
-
-    def test_close(self):
-        class Wrapfile(object):
-            def __init__(self, file):
-                self.file = open(file, 'rb')
-                self.closed = False
-            def close(self):
-                self.file.close()
-                self.closed = True
-            def __getattr__(self, attr): return getattr(self.file, attr)
-        testfile = Wrapfile(self.sndfilepath)
-        f = self.f = aifc.open(testfile)
-        self.assertEqual(testfile.closed, False)
-        f.close()
-        self.assertEqual(testfile.closed, True)
-        testfile = open(TESTFN, 'wb')
-        fout = aifc.open(testfile, 'wb')
-        self.assertFalse(testfile.closed)
-        with self.assertRaises(aifc.Error):
-            fout.close()
-        self.assertTrue(testfile.closed)
-        fout.close() # do nothing
-
     def test_write_header_comptype_sampwidth(self):
         for comptype in (b'ULAW', b'ulaw', b'ALAW', b'alaw', b'G722'):
             fout = aifc.open(io.BytesIO(), 'wb')
@@ -375,10 +384,5 @@
         f.close()
 
 
-def test_main():
-    run_unittest(AIFCTest)
-    run_unittest(AIFCLowLevelTest)
-
-
 if __name__ == "__main__":
     unittest.main()
diff --git a/Lib/test/test_audioop.py b/Lib/test/test_audioop.py
--- a/Lib/test/test_audioop.py
+++ b/Lib/test/test_audioop.py
@@ -6,13 +6,18 @@
 def pack(width, data):
     return b''.join(v.to_bytes(width, sys.byteorder, signed=True) for v in data)
 
-packs = {w: (lambda *data, width=w: pack(width, data)) for w in (1, 2, 4)}
-maxvalues = {w: (1 << (8 * w - 1)) - 1 for w in (1, 2, 4)}
-minvalues = {w: -1 << (8 * w - 1) for w in (1, 2, 4)}
+def unpack(width, data):
+    return [int.from_bytes(data[i: i + width], sys.byteorder, signed=True)
+            for i in range(0, len(data), width)]
+
+packs = {w: (lambda *data, width=w: pack(width, data)) for w in (1, 2, 3, 4)}
+maxvalues = {w: (1 << (8 * w - 1)) - 1 for w in (1, 2, 3, 4)}
+minvalues = {w: -1 << (8 * w - 1) for w in (1, 2, 3, 4)}
 
 datas = {
     1: b'\x00\x12\x45\xbb\x7f\x80\xff',
     2: packs[2](0, 0x1234, 0x4567, -0x4567, 0x7fff, -0x8000, -1),
+    3: packs[3](0, 0x123456, 0x456789, -0x456789, 0x7fffff, -0x800000, -1),
     4: packs[4](0, 0x12345678, 0x456789ab, -0x456789ab,
                 0x7fffffff, -0x80000000, -1),
 }
@@ -20,6 +25,7 @@
 INVALID_DATA = [
     (b'abc', 0),
     (b'abc', 2),
+    (b'ab', 3),
     (b'abc', 4),
 ]
 
@@ -27,7 +33,7 @@
 class TestAudioop(unittest.TestCase):
 
     def test_max(self):
-        for w in 1, 2, 4:
+        for w in 1, 2, 3, 4:
             self.assertEqual(audioop.max(b'', w), 0)
             p = packs[w]
             self.assertEqual(audioop.max(p(5), w), 5)
@@ -37,7 +43,7 @@
             self.assertEqual(audioop.max(datas[w], w), -minvalues[w])
 
     def test_minmax(self):
-        for w in 1, 2, 4:
+        for w in 1, 2, 3, 4:
             self.assertEqual(audioop.minmax(b'', w),
                              (0x7fffffff, -0x80000000))
             p = packs[w]
@@ -51,7 +57,7 @@
                              (minvalues[w], maxvalues[w]))
 
     def test_maxpp(self):
-        for w in 1, 2, 4:
+        for w in 1, 2, 3, 4:
             self.assertEqual(audioop.maxpp(b'', w), 0)
             self.assertEqual(audioop.maxpp(packs[w](*range(100)), w), 0)
             self.assertEqual(audioop.maxpp(packs[w](9, 10, 5, 5, 0, 1), w), 10)
@@ -59,7 +65,7 @@
                              maxvalues[w] - minvalues[w])
 
     def test_avg(self):
-        for w in 1, 2, 4:
+        for w in 1, 2, 3, 4:
             self.assertEqual(audioop.avg(b'', w), 0)
             p = packs[w]
             self.assertEqual(audioop.avg(p(5), w), 5)
@@ -75,7 +81,7 @@
                          -0x60000000)
 
     def test_avgpp(self):
-        for w in 1, 2, 4:
+        for w in 1, 2, 3, 4:
             self.assertEqual(audioop.avgpp(b'', w), 0)
             self.assertEqual(audioop.avgpp(packs[w](*range(100)), w), 0)
             self.assertEqual(audioop.avgpp(packs[w](9, 10, 5, 5, 0, 1), w), 10)
@@ -84,7 +90,7 @@
         self.assertEqual(audioop.avgpp(datas[4], 4), 3311897002)
 
     def test_rms(self):
-        for w in 1, 2, 4:
+        for w in 1, 2, 3, 4:
             self.assertEqual(audioop.rms(b'', w), 0)
             p = packs[w]
             self.assertEqual(audioop.rms(p(*range(100)), w), 57)
@@ -97,7 +103,7 @@
         self.assertEqual(audioop.rms(datas[4], 4), 1310854152)
 
     def test_cross(self):
-        for w in 1, 2, 4:
+        for w in 1, 2, 3, 4:
             self.assertEqual(audioop.cross(b'', w), -1)
             p = packs[w]
             self.assertEqual(audioop.cross(p(0, 1, 2), w), 0)
@@ -107,7 +113,7 @@
             self.assertEqual(audioop.cross(p(minvalues[w], maxvalues[w]), w), 1)
 
     def test_add(self):
-        for w in 1, 2, 4:
+        for w in 1, 2, 3, 4:
             self.assertEqual(audioop.add(b'', b'', w), b'')
             self.assertEqual(audioop.add(datas[w], b'\0' * len(datas[w]), w),
                              datas[w])
@@ -120,7 +126,7 @@
                        0x7fffffff, -0x80000000, -2))
 
     def test_bias(self):
-        for w in 1, 2, 4:
+        for w in 1, 2, 3, 4:
             for bias in 0, 1, -1, 127, -128, 0x7fffffff, -0x80000000:
                 self.assertEqual(audioop.bias(b'', w, bias), b'')
         self.assertEqual(audioop.bias(datas[1], 1, 1),
@@ -153,7 +159,7 @@
                          -1, 0, 0x7fffffff))
 
     def test_lin2lin(self):
-        for w in 1, 2, 4:
+        for w in 1, 2, 3, 4:
             self.assertEqual(audioop.lin2lin(datas[w], w, w), datas[w])
 
         self.assertEqual(audioop.lin2lin(datas[1], 1, 2),
@@ -181,7 +187,7 @@
                                    -0xb30000), (-179, 40)))
 
         # Very cursory test
-        for w in 1, 2, 4:
+        for w in 1, 2, 3, 4:
             self.assertEqual(audioop.adpcm2lin(b'\0' * 5, w, None),
                              (b'\0' * w * 10, (0, 0)))
 
@@ -194,7 +200,7 @@
                          (b'\x07\x7f\x7f', (31, 39)))
 
         # Very cursory test
-        for w in 1, 2, 4:
+        for w in 1, 2, 3, 4:
             self.assertEqual(audioop.lin2adpcm(b'\0' * w * 10, w, None),
                              (b'\0' * 5, (0, 0)))
 
@@ -211,12 +217,12 @@
                   b'\x80\x83\xa4\xaa\xd1\xd4\xd5\xd8\xeb\xf1\xff'
         src = [-688, -720, -2240, -4032, -9, -3, -1, -27, -244, -82, -106,
                688, 720, 2240, 4032, 9, 3, 1, 27, 244, 82, 106]
-        for w in 1, 2, 4:
+        for w in 1, 2, 3, 4:
             self.assertEqual(audioop.alaw2lin(encoded, w),
                              packs[w](*(x << (w * 8) >> 13 for x in src)))
 
         encoded = bytes(range(256))
-        for w in 2, 4:
+        for w in 2, 3, 4:
             decoded = audioop.alaw2lin(encoded, w)
             self.assertEqual(audioop.lin2alaw(decoded, w), encoded)
 
@@ -233,18 +239,18 @@
                   b'\x80\x8e\xa8\xbf\xd7\xea\xf6\xfc\xfe\xff'
         src = [-8031, -4447, -1471, -495, -163, -53, -18, -6, -2, 0,
                8031, 4447, 1471, 495, 163, 53, 18, 6, 2, 0]
-        for w in 1, 2, 4:
+        for w in 1, 2, 3, 4:
             self.assertEqual(audioop.ulaw2lin(encoded, w),
                              packs[w](*(x << (w * 8) >> 14 for x in src)))
 
         # Current u-law implementation has two codes fo 0: 0x7f and 0xff.
         encoded = bytes(range(127)) + bytes(range(128, 256))
-        for w in 2, 4:
+        for w in 2, 3, 4:
             decoded = audioop.ulaw2lin(encoded, w)
             self.assertEqual(audioop.lin2ulaw(decoded, w), encoded)
 
     def test_mul(self):
-        for w in 1, 2, 4:
+        for w in 1, 2, 3, 4:
             self.assertEqual(audioop.mul(b'', w, 2), b'')
             self.assertEqual(audioop.mul(datas[w], w, 0),
                              b'\0' * len(datas[w]))
@@ -259,7 +265,7 @@
                          0x7fffffff, -0x80000000, -2))
 
     def test_ratecv(self):
-        for w in 1, 2, 4:
+        for w in 1, 2, 3, 4:
             self.assertEqual(audioop.ratecv(b'', w, 1, 8000, 8000, None),
                              (b'', (-1, ((0, 0),))))
             self.assertEqual(audioop.ratecv(b'', w, 5, 8000, 8000, None),
@@ -273,7 +279,7 @@
         d2, state = audioop.ratecv(b'\x00\x01\x02', 1, 1, 8000, 16000, state)
         self.assertEqual(d1 + d2, b'\000\000\001\001\002\001\000\000\001\001\002')
 
-        for w in 1, 2, 4:
+        for w in 1, 2, 3, 4:
             d0, state0 = audioop.ratecv(datas[w], w, 1, 8000, 16000, None)
             d, state = b'', None
             for i in range(0, len(datas[w]), w):
@@ -284,13 +290,13 @@
             self.assertEqual(state, state0)
 
     def test_reverse(self):
-        for w in 1, 2, 4:
+        for w in 1, 2, 3, 4:
             self.assertEqual(audioop.reverse(b'', w), b'')
             self.assertEqual(audioop.reverse(packs[w](0, 1, 2), w),
                              packs[w](2, 1, 0))
 
     def test_tomono(self):
-        for w in 1, 2, 4:
+        for w in 1, 2, 3, 4:
             data1 = datas[w]
             data2 = bytearray(2 * len(data1))
             for k in range(w):
@@ -302,7 +308,7 @@
             self.assertEqual(audioop.tomono(data2, w, 0.5, 0.5), data1)
 
     def test_tostereo(self):
-        for w in 1, 2, 4:
+        for w in 1, 2, 3, 4:
             data1 = datas[w]
             data2 = bytearray(2 * len(data1))
             for k in range(w):
@@ -329,7 +335,7 @@
         self.assertEqual(audioop.findmax(datas[2], 1), 5)
 
     def test_getsample(self):
-        for w in 1, 2, 4:
+        for w in 1, 2, 3, 4:
             data = packs[w](0, 1, -1, maxvalues[w], minvalues[w])
             self.assertEqual(audioop.getsample(data, w, 0), 0)
             self.assertEqual(audioop.getsample(data, w, 1), 1)
@@ -369,7 +375,7 @@
     def test_wrongsize(self):
         data = b'abcdefgh'
         state = None
-        for size in (-1, 0, 3, 5, 1024):
+        for size in (-1, 0, 5, 1024):
             self.assertRaises(audioop.error, audioop.ulaw2lin, data, size)
             self.assertRaises(audioop.error, audioop.alaw2lin, data, size)
             self.assertRaises(audioop.error, audioop.adpcm2lin, data, size, state)
diff --git a/Lib/test/test_sunau.py b/Lib/test/test_sunau.py
--- a/Lib/test/test_sunau.py
+++ b/Lib/test/test_sunau.py
@@ -1,128 +1,98 @@
-from test.support import TESTFN, unlink
+from test.support import TESTFN
 import unittest
-import pickle
-import os
-
+from test import audiotests
+import sys
 import sunau
 
-nchannels = 2
-sampwidth = 2
-framerate = 8000
-nframes = 100
 
-class SunAUTest(unittest.TestCase):
+class SunauPCM8Test(audiotests.AudioWriteTests,
+                    audiotests.AudioTestsWithSourceFile,
+                    unittest.TestCase):
+    module = sunau
+    sndfilename = 'pcm8.au'
+    sndfilenframes = 48
+    nchannels = 2
+    sampwidth = 1
+    framerate = 48000
+    nframes = 48
+    comptype = 'NONE'
+    compname = 'not compressed'
+    frames = bytes.fromhex(
+    '0000 0C0C 1717 2222 2D2D 3737 3F3F 4747 4E4E 5353 5757 5959 5A5A 5959'\
+    '5757 5353 4E4E 4747 4040 3737 2D2D 2222 1717 0C0C 0000 F4F4 E9E9 DEDE'\
+    'D3D3 C9C9 C1C1 B9B9 B2B2 ADAD A9A9 A7A7 A6A6 A7A7 A9A9 ADAD B2B2 B9B9'\
+    'C0C0 C9C9 D3D3 DEDE E9E9 F4F4')
 
-    def setUp(self):
-        self.f = None
 
-    def tearDown(self):
-        if self.f is not None:
-            self.f.close()
-        unlink(TESTFN)
+class SunauPCM16Test(audiotests.AudioWriteTests,
+                     audiotests.AudioTestsWithSourceFile,
+                     unittest.TestCase):
+    module = sunau
+    sndfilename = 'pcm16.au'
+    sndfilenframes = 48
+    nchannels = 2
+    sampwidth = 2
+    framerate = 48000
+    nframes = 48
+    comptype = 'NONE'
+    compname = 'not compressed'
+    frames = bytes.fromhex(
+    '00000000 0BD00BD0 176D176D 22A322A3 2D412D41 37193719 3FFF3FFF 47CE47CE'\
+    '4E624E62 539E539E 576C576C 59BC59BC 5A825A82 59BC59BC 576C576C 539E539E'\
+    '4E624E62 47CE47CE 40004000 37193719 2D412D41 22A322A3 176D176D 0BD00BD0'\
+    '00000000 F430F430 E893E893 DD5DDD5D D2BFD2BF C8E7C8E7 C001C001 B832B832'\
+    'B19EB19E AC62AC62 A894A894 A644A644 A57EA57E A644A644 A894A894 AC62AC62'\
+    'B19EB19E B832B832 C000C000 C8E7C8E7 D2BFD2BF DD5DDD5D E893E893 F430F430')
 
-    def test_lin(self):
-        self.f = sunau.open(TESTFN, 'w')
-        self.f.setnchannels(nchannels)
-        self.f.setsampwidth(sampwidth)
-        self.f.setframerate(framerate)
-        self.f.setcomptype('NONE', 'not compressed')
-        output = b'\xff\x00\x12\xcc' * (nframes * nchannels * sampwidth // 4)
-        self.f.writeframes(output)
-        self.f.close()
 
-        self.f = sunau.open(TESTFN, 'rb')
-        self.assertEqual(nchannels, self.f.getnchannels())
-        self.assertEqual(sampwidth, self.f.getsampwidth())
-        self.assertEqual(framerate, self.f.getframerate())
-        self.assertEqual(nframes, self.f.getnframes())
-        self.assertEqual('NONE', self.f.getcomptype())
-        self.assertEqual(self.f.readframes(nframes), output)
-        self.f.close()
+class SunauPCM32Test(audiotests.AudioWriteTests,
+                     audiotests.AudioTestsWithSourceFile,
+                     unittest.TestCase):
+    module = sunau
+    sndfilename = 'pcm32.au'
+    sndfilenframes = 48
+    nchannels = 2
+    sampwidth = 4
+    framerate = 48000
+    nframes = 48
+    comptype = 'NONE'
+    compname = 'not compressed'
+    frames = bytes.fromhex(
+    '0000000000000000 0BD05A970BD05A97 176CF5D1176CF5D1 22A2F4F722A2F4F7'\
+    '2D413CCD2D413CCD 37194A9E37194A9E 3FFFFFFF3FFFFFFF 47CE5FAD47CE5FAD'\
+    '4E6238504E623850 539EBA44539EBA44 576CF5D0576CF5D0 59BC3F9559BC3F95'\
+    '5A8279995A827999 59BC3F9559BC3F95 576CF5D0576CF5D0 539EBA44539EBA44'\
+    '4E6238504E623850 47CE5FAD47CE5FAD 4000000040000000 37194A9E37194A9E'\
+    '2D413CCD2D413CCD 22A2F4F722A2F4F7 176CF5D1176CF5D1 0BD05A970BD05A97'\
+    '0000000000000000 F42FA569F42FA569 E8930A2FE8930A2F DD5D0B09DD5D0B09'\
+    'D2BEC333D2BEC333 C8E6B562C8E6B562 C0000001C0000001 B831A053B831A053'\
+    'B19DC7B0B19DC7B0 AC6145BCAC6145BC A8930A30A8930A30 A643C06BA643C06B'\
+    'A57D8667A57D8667 A643C06BA643C06B A8930A30A8930A30 AC6145BCAC6145BC'\
+    'B19DC7B0B19DC7B0 B831A053B831A053 C0000000C0000000 C8E6B562C8E6B562'\
+    'D2BEC333D2BEC333 DD5D0B09DD5D0B09 E8930A2FE8930A2F F42FA569F42FA569')
 
-    def test_ulaw(self):
-        self.f = sunau.open(TESTFN, 'w')
-        self.f.setnchannels(nchannels)
-        self.f.setsampwidth(sampwidth)
-        self.f.setframerate(framerate)
-        self.f.setcomptype('ULAW', '')
-        # u-law compression is lossy, therefore we can't expect non-zero data
-        # to come back unchanged.
-        output = b'\0' * nframes * nchannels * sampwidth
-        self.f.writeframes(output)
-        self.f.close()
 
-        self.f = sunau.open(TESTFN, 'rb')
-        self.assertEqual(nchannels, self.f.getnchannels())
-        self.assertEqual(sampwidth, self.f.getsampwidth())
-        self.assertEqual(framerate, self.f.getframerate())
-        self.assertEqual(nframes, self.f.getnframes())
-        self.assertEqual('ULAW', self.f.getcomptype())
-        self.assertEqual(self.f.readframes(nframes), output)
-        self.f.close()
-
-    def test_getparams(self):
-        self.f = sunau.open(TESTFN, 'w')
-        self.f.setnchannels(nchannels)
-        self.f.setsampwidth(sampwidth)
-        self.f.setframerate(framerate)
-        self.f.setcomptype('ULAW', '')
-        output = b'\0' * nframes * nchannels * sampwidth
-        self.f.writeframes(output)
-        self.f.close()
-
-        self.f = sunau.open(TESTFN, 'rb')
-        params = self.f.getparams()
-        self.assertEqual(params.nchannels, nchannels)
-        self.assertEqual(params.sampwidth, sampwidth)
-        self.assertEqual(params.framerate, framerate)
-        self.assertEqual(params.nframes, nframes)
-        self.assertEqual(params.comptype, 'ULAW')
-
-        dump = pickle.dumps(params)
-        self.assertEqual(pickle.loads(dump), params)
-
-    def test_write_context_manager_calls_close(self):
-        # Close checks for a minimum header and will raise an error
-        # if it is not set, so this proves that close is called.
-        with self.assertRaises(sunau.Error):
-            with sunau.open(TESTFN, 'wb') as f:
-                pass
-        with self.assertRaises(sunau.Error):
-            with open(TESTFN, 'wb') as testfile:
-                with sunau.open(testfile):
-                    pass
-
-    def test_context_manager_with_open_file(self):
-        with open(TESTFN, 'wb') as testfile:
-            with sunau.open(testfile) as f:
-                f.setnchannels(nchannels)
-                f.setsampwidth(sampwidth)
-                f.setframerate(framerate)
-            self.assertFalse(testfile.closed)
-        with open(TESTFN, 'rb') as testfile:
-            with sunau.open(testfile) as f:
-                self.assertFalse(f.getfp().closed)
-                params = f.getparams()
-                self.assertEqual(params[0], nchannels)
-                self.assertEqual(params[1], sampwidth)
-                self.assertEqual(params[2], framerate)
-            self.assertIsNone(f.getfp())
-            self.assertFalse(testfile.closed)
-
-    def test_context_manager_with_filename(self):
-        # If the file doesn't get closed, this test won't fail, but it will
-        # produce a resource leak warning.
-        with sunau.open(TESTFN, 'wb') as f:
-            f.setnchannels(nchannels)
-            f.setsampwidth(sampwidth)
-            f.setframerate(framerate)
-        with sunau.open(TESTFN) as f:
-            self.assertFalse(f.getfp().closed)
-            params = f.getparams()
-            self.assertEqual(params[0], nchannels)
-            self.assertEqual(params[1], sampwidth)
-            self.assertEqual(params[2], framerate)
-        self.assertIsNone(f.getfp())
+class SunauULAWTest(audiotests.AudioWriteTests,
+                    audiotests.AudioTestsWithSourceFile,
+                    unittest.TestCase):
+    module = sunau
+    sndfilename = 'ulaw.au'
+    sndfilenframes = 48
+    nchannels = 2
+    sampwidth = 2
+    framerate = 48000
+    nframes = 48
+    comptype = 'ULAW'
+    compname = 'CCITT G.711 u-law'
+    frames = bytes.fromhex(
+    '00000000 0BBC0BBC 16FC16FC 227C227C 2C7C2C7C 367C367C 417C417C 497C497C'\
+    '4D7C4D7C 557C557C 557C557C 597C597C 597C597C 597C597C 557C557C 557C557C'\
+    '4D7C4D7C 497C497C 417C417C 367C367C 2C7C2C7C 227C227C 16FC16FC 0BBC0BBC'\
+    '00000000 F444F444 E904E904 DD84DD84 D384D384 C984C984 BE84BE84 B684B684'\
+    'B284B284 AA84AA84 AA84AA84 A684A684 A684A684 A684A684 AA84AA84 AA84AA84'\
+    'B284B284 B684B684 BE84BE84 C984C984 D384D384 DD84DD84 E904E904 F444F444')
+    if sys.byteorder != 'big':
+        frames = audiotests.byteswap2(frames)
 
 
 if __name__ == "__main__":
diff --git a/Lib/test/test_wave.py b/Lib/test/test_wave.py
--- a/Lib/test/test_wave.py
+++ b/Lib/test/test_wave.py
@@ -1,129 +1,126 @@
-from test.support import TESTFN, unlink
+from test.support import TESTFN
+import unittest
+from test import audiotests
 import wave
-import pickle
-import unittest
 
-nchannels = 2
-sampwidth = 2
-framerate = 8000
-nframes = 100
 
-class TestWave(unittest.TestCase):
+class WavePCM8Test(audiotests.AudioWriteTests,
+                   audiotests.AudioTestsWithSourceFile,
+                   unittest.TestCase):
+    module = wave
+    sndfilename = 'pcm8.wav'
+    sndfilenframes = 48
+    nchannels = 2
+    sampwidth = 1
+    framerate = 48000
+    nframes = 48
+    comptype = 'NONE'
+    compname = 'not compressed'
+    frames = bytes.fromhex(
+    '8080 8C8C 9797 A2A2 ADAD B7B7 BFBF C7C7 CECE D3D3 D7D7 D9D9 DADA D9D9'\
+    'D7D7 D3D3 CECE C7C7 C0C0 B7B7 ADAD A2A2 9797 8C8C 8080 7474 6969 5E5E'\
+    '5353 4949 4141 3939 3232 2D2D 2929 2727 2626 2727 2929 2D2D 3232 3939'\
+    '4040 4949 5353 5E5E 6969 7474')
 
-    def setUp(self):
-        self.f = None
 
-    def tearDown(self):
-        if self.f is not None:
-            self.f.close()
-        unlink(TESTFN)
-
-    def test_it(self, test_rounding=False):
-        self.f = wave.open(TESTFN, 'wb')
-        self.f.setnchannels(nchannels)
-        self.f.setsampwidth(sampwidth)
-        if test_rounding:
-            self.f.setframerate(framerate - 0.1)
-        else:
-            self.f.setframerate(framerate)
-        self.f.setnframes(nframes)
-        output = b'\0' * nframes * nchannels * sampwidth
-        self.f.writeframes(output)
-        self.f.close()
-
-        self.f = wave.open(TESTFN, 'rb')
-        self.assertEqual(nchannels, self.f.getnchannels())
-        self.assertEqual(sampwidth, self.f.getsampwidth())
-        self.assertEqual(framerate, self.f.getframerate())
-        self.assertEqual(nframes, self.f.getnframes())
-        self.assertEqual(self.f.readframes(nframes), output)
+class WavePCM16Test(audiotests.AudioWriteTests,
+                    audiotests.AudioTestsWithSourceFile,
+                    unittest.TestCase):
+    module = wave
+    sndfilename = 'pcm16.wav'
+    sndfilenframes = 48
+    nchannels = 2
+    sampwidth = 2
+    framerate = 48000
+    nframes = 48
+    comptype = 'NONE'
+    compname = 'not compressed'
+    frames = bytes.fromhex(
+    '00000000 0BD00BD0 176D176D 22A322A3 2D412D41 37193719 3FFF3FFF 47CE47CE'\
+    '4E624E62 539E539E 576C576C 59BC59BC 5A825A82 59BC59BC 576C576C 539E539E'\
+    '4E624E62 47CE47CE 40004000 37193719 2D412D41 22A322A3 176D176D 0BD00BD0'\
+    '00000000 F430F430 E893E893 DD5DDD5D D2BFD2BF C8E7C8E7 C001C001 B832B832'\
+    'B19EB19E AC62AC62 A894A894 A644A644 A57EA57E A644A644 A894A894 AC62AC62'\
+    'B19EB19E B832B832 C000C000 C8E7C8E7 D2BFD2BF DD5DDD5D E893E893 F430F430')
+    frames = audiotests.byteswap2(frames)
 
     def test_fractional_framerate(self):
         """
         Addresses [ 1512791 ] module wave does no rounding
         Floating point framerates should be rounded, rather than truncated.
         """
-        self.test_it(test_rounding=True)
+        f = self.f = self.module.open(TESTFN, 'wb')
+        f.setnchannels(self.nchannels)
+        f.setsampwidth(self.sampwidth)
+        f.setframerate(self.framerate - 0.1)
+        f.setcomptype(self.comptype, self.compname)
+        f.setnframes(self.nframes)
+        f.writeframes(self.frames)
+        f.close()
+
+        self.check_file(TESTFN, self.nframes, self.frames)
 
     def test_issue7681(self):
         self.f = wave.open(TESTFN, 'wb')
-        self.f.setnchannels(nchannels)
-        self.f.setsampwidth(sampwidth)
-        self.f.setframerate(framerate)
+        self.f.setnchannels(self.nchannels)
+        self.f.setsampwidth(self.sampwidth)
+        self.f.setframerate(self.framerate)
         # Don't call setnframes, make _write_header divide to figure it out
-        output = b'\0' * nframes * nchannels * sampwidth
+        output = b'\0' * self.nframes * self.nchannels * self.sampwidth
         self.f.writeframes(output)
 
-    def test_getparams(self):
-        self.f = wave.open(TESTFN, 'wb')
-        self.f.setnchannels(nchannels)
-        self.f.setsampwidth(sampwidth)
-        self.f.setframerate(framerate)
-        self.f.close()
+class WavePCM24Test(audiotests.AudioWriteTests,
+                    audiotests.AudioTestsWithSourceFile,
+                    unittest.TestCase):
+    module = wave
+    sndfilename = 'pcm24.wav'
+    sndfilenframes = 48
+    nchannels = 2
+    sampwidth = 3
+    framerate = 48000
+    nframes = 48
+    comptype = 'NONE'
+    compname = 'not compressed'
+    frames = bytes.fromhex(
+    '000000000000 0BD05A0BD05A 176CF6176CF6 22A2F522A2F5 2D413C2D413C'\
+    '37194A37194A 3FFFFF3FFFFF 47CE5F47CE5F 4E62384E6238 539EBA539EBA'\
+    '576CF5576CF5 59BC3F59BC3F 5A82795A8279 59BC3F59BC3F 576CF5576CF5'\
+    '539EBA539EBA 4E62384E6238 47CE5F47CE5F 400000400000 37194A37194A'\
+    '2D413C2D413C 22A2F522A2F5 176CF6176CF6 0BD05A0BD05A 000000000000'\
+    'F42FA6F42FA6 E8930AE8930A DD5D0BDD5D0B D2BEC4D2BEC4 C8E6B6C8E6B6'\
+    'C00001C00001 B831A1B831A1 B19DC8B19DC8 AC6146AC6146 A8930BA8930B'\
+    'A643C1A643C1 A57D87A57D87 A643C1A643C1 A8930BA8930B AC6146AC6146'\
+    'B19DC8B19DC8 B831A1B831A1 C00000C00000 C8E6B6C8E6B6 D2BEC4D2BEC4'\
+    'DD5D0BDD5D0B E8930AE8930A F42FA6F42FA6')
+    frames = audiotests.byteswap3(frames)
 
-        self.f = wave.open(TESTFN, 'rb')
-        params = self.f.getparams()
-        self.assertEqual(params.nchannels, self.f.getnchannels())
-        self.assertEqual(params.nframes, self.f.getnframes())
-        self.assertEqual(params.sampwidth, self.f.getsampwidth())
-        self.assertEqual(params.framerate, self.f.getframerate())
-        self.assertEqual(params.comptype, self.f.getcomptype())
-        self.assertEqual(params.compname, self.f.getcompname())
 
-    def test_getparams_picklable(self):
-        self.f = wave.open(TESTFN, 'wb')
-        self.f.setnchannels(nchannels)
-        self.f.setsampwidth(sampwidth)
-        self.f.setframerate(framerate)
-        self.f.close()
-
-        self.f = wave.open(TESTFN, 'rb')
-        params = self.f.getparams()
-        dump = pickle.dumps(params)
-        self.assertEqual(pickle.loads(dump), params)
-
-    def test_wave_write_context_manager_calls_close(self):
-        # Close checks for a minimum header and will raise an error
-        # if it is not set, so this proves that close is called.
-        with self.assertRaises(wave.Error):
-            with wave.open(TESTFN, 'wb') as f:
-                pass
-        with self.assertRaises(wave.Error):
-            with open(TESTFN, 'wb') as testfile:
-                with wave.open(testfile):
-                    pass
-
-    def test_context_manager_with_open_file(self):
-        with open(TESTFN, 'wb') as testfile:
-            with wave.open(testfile) as f:
-                f.setnchannels(nchannels)
-                f.setsampwidth(sampwidth)
-                f.setframerate(framerate)
-            self.assertFalse(testfile.closed)
-        with open(TESTFN, 'rb') as testfile:
-            with wave.open(testfile) as f:
-                self.assertFalse(f.getfp().closed)
-                params = f.getparams()
-                self.assertEqual(params.nchannels, nchannels)
-                self.assertEqual(params.sampwidth, sampwidth)
-                self.assertEqual(params.framerate, framerate)
-            self.assertIsNone(f.getfp())
-            self.assertFalse(testfile.closed)
-
-    def test_context_manager_with_filename(self):
-        # If the file doesn't get closed, this test won't fail, but it will
-        # produce a resource leak warning.
-        with wave.open(TESTFN, 'wb') as f:
-            f.setnchannels(nchannels)
-            f.setsampwidth(sampwidth)
-            f.setframerate(framerate)
-        with wave.open(TESTFN) as f:
-            self.assertFalse(f.getfp().closed)
-            params = f.getparams()
-            self.assertEqual(params.nchannels, nchannels)
-            self.assertEqual(params.sampwidth, sampwidth)
-            self.assertEqual(params.framerate, framerate)
-        self.assertIsNone(f.getfp())
+class WavePCM24Test(audiotests.AudioWriteTests,
+                    audiotests.AudioTestsWithSourceFile,
+                    unittest.TestCase):
+    module = wave
+    sndfilename = 'pcm32.wav'
+    sndfilenframes = 48
+    nchannels = 2
+    sampwidth = 4
+    framerate = 48000
+    nframes = 48
+    comptype = 'NONE'
+    compname = 'not compressed'
+    frames = bytes.fromhex(
+    '0000000000000000 0BD05A970BD05A97 176CF5D1176CF5D1 22A2F4F722A2F4F7'\
+    '2D413CCD2D413CCD 37194A9E37194A9E 3FFFFFFF3FFFFFFF 47CE5FAD47CE5FAD'\
+    '4E6238504E623850 539EBA44539EBA44 576CF5D0576CF5D0 59BC3F9559BC3F95'\
+    '5A8279995A827999 59BC3F9559BC3F95 576CF5D0576CF5D0 539EBA44539EBA44'\
+    '4E6238504E623850 47CE5FAD47CE5FAD 4000000040000000 37194A9E37194A9E'\
+    '2D413CCD2D413CCD 22A2F4F722A2F4F7 176CF5D1176CF5D1 0BD05A970BD05A97'\
+    '0000000000000000 F42FA569F42FA569 E8930A2FE8930A2F DD5D0B09DD5D0B09'\
+    'D2BEC333D2BEC333 C8E6B562C8E6B562 C0000001C0000001 B831A053B831A053'\
+    'B19DC7B0B19DC7B0 AC6145BCAC6145BC A8930A30A8930A30 A643C06BA643C06B'\
+    'A57D8667A57D8667 A643C06BA643C06B A8930A30A8930A30 AC6145BCAC6145BC'\
+    'B19DC7B0B19DC7B0 B831A053B831A053 C0000000C0000000 C8E6B562C8E6B562'\
+    'D2BEC333D2BEC333 DD5D0B09DD5D0B09 E8930A2FE8930A2F F42FA569F42FA569')
+    frames = audiotests.byteswap4(frames)
 
 
 if __name__ == '__main__':