diff --git a/suite/audio_quality/test_description/dut_recording_spectrum.xml b/suite/audio_quality/test_description/dut_recording_spectrum.xml
index 0f58deb..2bfe661 100644
--- a/suite/audio_quality/test_description/dut_recording_spectrum.xml
+++ b/suite/audio_quality/test_description/dut_recording_spectrum.xml
@@ -17,22 +17,21 @@
 
 <case name="dut_recording_spectrum" version="1.0" description="Check frequency spectrum for recording">
 	<setup>
-		<!-- input: peak amplitude, duration in msec, sampling rate, low frequency, high frequency, output: generated sound-->
-		<process method="script:gen_random" input="consti:10000,consti:30000,consti:44100,consti:50,consti:6000" output="id:sound1" />
-		<!-- sound id="sound1" type="random:10000:30000" / -->
+		<!-- input: peak amplitude, duration in msec, sampling rate, high frequency, output: generated sound-->
+		<process method="script:gen_random" input="consti:10000,consti:30000,consti:44100,consti:6000" output="id:sound1" />
 		<!--  Only for starting client app early. The data is not used -->
 		<sound id="sound2" type="sin:1:1000:2" preload="1"/>
 	</setup>
 	<action>
 		<sequential repeat="1" index="i">
 			<output device="host" id="sound1" gain="100" sync="start" waitforcompletion="0" />
-			<sequential repeat="1" index="j">
+			<sequential repeat="5" index="j">
 				<input device="host" id="host_in_$j" gain="100" time="6000" sync="start" />
 				<input device="DUT" id="dut_in_$j" gain="100" time="4000" sync="start" />
 			</sequential>
 		</sequential>
-		<sequential repeat="1" index="k">
-			<!-- input: host record, device record, samping rate, low frequency in Hz, high frequency in Hz, allowed error for pass in smaller side, allowed error in bigger side%, output: min value in lower side calculated normalized to 1.0, max value in higher side, calculated TF in mannitude only between low f to high f -->
+		<sequential repeat="5" index="k">
+			<!-- input: host record, device record, samping rate, low frequency in Hz, high frequency in Hz, allowed error for pass in smaller side, allowed error in bigger side%, output: min value in lower side calculated normalized to 1.0, max value in higher side, calculated amplitude ratio in mannitude only between low f to high f -->
 			<process method="script:check_spectrum" input="id:host_in_$k,id:dut_in_$k,consti:44100,consti:200,consti:4000,constf:50.0,constf:100.0" output="val:min_val_$k,val:max_val_$k,id:tf_$k" />
 		</sequential>
 	</action>
diff --git a/suite/audio_quality/test_description/processing/check_spectrum.py b/suite/audio_quality/test_description/processing/check_spectrum.py
index 31b5a5e..913b88c 100644
--- a/suite/audio_quality/test_description/processing/check_spectrum.py
+++ b/suite/audio_quality/test_description/processing/check_spectrum.py
@@ -23,7 +23,7 @@
 sys.path.append(sys.path[0])
 import calc_delay
 
-# check if Transfer Function of DUT / Host signal
+# check if amplitude ratio of DUT / Host signal
 #  lies in the given error boundary
 # input: host record
 #        device record,
@@ -34,35 +34,42 @@
 #        allowed error ih positive side for pass
 # output: min value in negative side, normalized to 1.0
 #         max value in positive side
-#         calculated TF in magnitude (DUT / Host)
+#         calculated amplittude ratio in magnitude (DUT / Host)
 
 def do_check_spectrum(hostData, DUTData, samplingRate, fLow, fHigh, margainLow, margainHigh):
     # reduce FFT resolution to have averaging effects
-    N = 512 if (len(hostData) > 512) else len(hostData)
-    iLow = N * fLow / samplingRate
+    N = 256 if (len(hostData) > 512) else len(hostData)
+    iLow = N * fLow / samplingRate + 1 # 1 for DC
     if iLow > (N / 2 - 1):
         iLow = (N / 2 - 1)
-    iHigh = N * fHigh / samplingRate
-    if iHigh > (N / 2):
-        iHigh = N / 2
+    iHigh = N * fHigh / samplingRate + 1 # 1 for DC
+    if iHigh > (N / 2 + 1):
+        iHigh = N / 2 + 1
     print fLow, iLow, fHigh, iHigh, samplingRate
-    hostFFT = abs(fft.fft(hostData, n = N))[iLow:iHigh]
-    dutFFT = abs(fft.fft(DUTData, n = N))[iLow:iHigh]
-    TF = dutFFT / hostFFT
-    TFmean = sum(TF) / len(TF)
-    TF = TF / TFmean # TF normalized to 1
-    positiveMax = abs(max(TF))
-    negativeMin = abs(min(TF))
+
+    Phh, freqs = plt.psd(hostData, NFFT=N, Fs=samplingRate, Fc=0, detrend=plt.mlab.detrend_none,\
+        window=plt.mlab.window_hanning, noverlap=0, pad_to=None, sides='onesided',\
+        scale_by_freq=False)
+    Pdd, freqs = plt.psd(DUTData, NFFT=N, Fs=samplingRate, Fc=0, detrend=plt.mlab.detrend_none,\
+        window=plt.mlab.window_hanning, noverlap=0, pad_to=None, sides='onesided',\
+        scale_by_freq=False)
+    print len(Phh), len(Pdd)
+    print "Phh", abs(Phh[iLow:iHigh])
+    print "Pdd", abs(Pdd[iLow:iHigh])
+    amplitudeRatio = np.sqrt(abs(Pdd[iLow:iHigh]/Phh[iLow:iHigh]))
+    ratioMean = np.mean(amplitudeRatio)
+    amplitudeRatio = amplitudeRatio / ratioMean
+    print "Normialized ratio", amplitudeRatio
+    print "ration mean for normalization", ratioMean
+    positiveMax = abs(max(amplitudeRatio))
+    negativeMin = abs(min(amplitudeRatio))
     passFail = True if (positiveMax < (margainHigh / 100.0 + 1.0)) and\
         ((1.0 - negativeMin) < margainLow / 100.0) else False
-    TFResult = np.zeros(len(TF), dtype=np.int16)
-    for i in range(len(TF)):
-        TFResult[i] = TF[i] * 256 # make fixed point
-    #freq = np.linspace(0.0, fHigh, num=iHigh, endpoint=False)
-    #plt.plot(freq, abs(fft.fft(hostData, n = N))[:iHigh], freq, abs(fft.fft(DUTData, n = N))[:iHigh])
-    #plt.show()
+    RatioResult = np.zeros(len(amplitudeRatio), dtype=np.int16)
+    for i in range(len(amplitudeRatio)):
+        RatioResult[i] = amplitudeRatio[i] * 256 # make fixed point
     print "positiveMax", positiveMax, "negativeMin", negativeMin
-    return (passFail, negativeMin, positiveMax, TFResult)
+    return (passFail, negativeMin, positiveMax, RatioResult)
 
 def check_spectrum(inputData, inputTypes):
     output = []
@@ -125,10 +132,10 @@
     samplingRate = 44100
     fLow = 500
     fHigh = 15000
-    data = getattr(mod, "do_gen_random")(peakAmpl, durationInMSec, samplingRate, fLow, fHigh,\
-                                         stereo=False)
+    data = getattr(mod, "do_gen_random")(peakAmpl, durationInMSec, samplingRate, fHigh,\
+        stereo=False)
     print len(data)
-    (passFail, minVal, maxVal, TF) = do_check_spectrum(data, data, samplingRate, fLow, fHigh,\
-                                                           1.0, 1.0)
-    plt.plot(TF)
+    (passFail, minVal, maxVal, ampRatio) = do_check_spectrum(data, data, samplingRate, fLow, fHigh,\
+        1.0, 1.0)
+    plt.plot(ampRatio)
     plt.show()
diff --git a/suite/audio_quality/test_description/processing/gen_random.py b/suite/audio_quality/test_description/processing/gen_random.py
index 541c60a..305526a 100644
--- a/suite/audio_quality/test_description/processing/gen_random.py
+++ b/suite/audio_quality/test_description/processing/gen_random.py
@@ -20,32 +20,24 @@
 import scipy.fftpack as fft
 import matplotlib.pyplot as plt
 
-# generate random signal
+# generate random signal with max freq
 # Input: peak amplitude,
 #        duration in msec,
 #        sampling rate HZ
-#        low frequency,
 #        high frequency,
 # Output: generated sound (stereo)
 
-def do_gen_random(peakAmpl, durationInMSec, samplingRate, fLow, fHigh, stereo=True):
+def do_gen_random(peakAmpl, durationInMSec, samplingRate, fHigh, stereo=True):
     samples = durationInMSec * samplingRate / 1000
     result = np.zeros(samples * 2 if stereo else samples, dtype=np.int16)
-    #randomSignal = np.random.random_integers(-peakAmpl, peakAmpl, samples)
-    randomSignal = np.random.normal(scale=peakAmpl *2 / 3, size=samples)
+    randomSignal = np.random.normal(scale = peakAmpl * 2 / 3, size=samples)
     fftData = fft.rfft(randomSignal)
     freqSamples = samples/2
-    iLow = 0 #freqSamples * fLow * 2/ samplingRate + 1
-    #if iLow > freqSamples - 1:
-    #    iLow = freqSamples - 1
     iHigh = freqSamples * fHigh * 2 / samplingRate + 1
-    #print len(randomSignal), len(fftData), fLow, iLow, fHigh, iHigh
+    #print len(randomSignal), len(fftData), fLow, fHigh, iHigh
     if iHigh > freqSamples - 1:
         iHigh = freqSamples - 1
     fftData[0] = 0 # DC
-    #for i in range(iLow - 1):
-    #    fftData[2 * i + 1 ] = 0 # Re
-    #    fftData[2 * i + 2 ] = 0 # Imag
     for i in range(iHigh, freqSamples - 1):
         fftData[ 2 * i + 1 ] = 0
         fftData[ 2 * i + 2 ] = 0
@@ -81,15 +73,13 @@
         inputError = True
     if (inputTypes[3] != TYPE_I64):
         inputError = True
-    if (inputTypes[4] != TYPE_I64):
-        inputError = True
     if inputError:
         output.append(RESULT_ERROR)
         output.append(outputData)
         output.append(outputTypes)
         return output
 
-    result = do_gen_random(inputData[0], inputData[1], inputData[2], inputData[3], inputData[4])
+    result = do_gen_random(inputData[0], inputData[1], inputData[2], inputData[3])
 
     output.append(RESULT_OK)
     outputData.append(result)
@@ -103,8 +93,8 @@
     peakAmplitude = 10000
     samplingRate = 44100
     durationInMSec = 10000
-    fLow = 500
+    #fLow = 500
     fHigh = 15000
-    result = do_gen_random(peakAmplitude, durationInMSec, samplingRate, fLow, fHigh)
+    result = do_gen_random(peakAmplitude, durationInMSec, samplingRate, fHigh)
     plt.plot(result)
     plt.show()
diff --git a/suite/audio_quality/test_description/review/review_dut_recording_spectrum.xml b/suite/audio_quality/test_description/review/review_dut_recording_spectrum.xml
new file mode 100644
index 0000000..b8157be
--- /dev/null
+++ b/suite/audio_quality/test_description/review/review_dut_recording_spectrum.xml
@@ -0,0 +1,38 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<!-- Copyright (C) 2012 The Android Open Source Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+
+<case name="review_dut_recording_spectrum" version="1.0" description="Review">
+	<setup>
+		<sound id="sound_host_0" type="file:reports/2012_05_14_09_27_40/dut_recording_spectrum/host_in_0.r2m" />
+		<sound id="sound_dut_0" type="file:reports/2012_05_14_09_27_40/dut_recording_spectrum/dut_in_0.r2m" />
+		<sound id="sound_host_1" type="file:reports/2012_05_14_09_27_40/dut_recording_spectrum/host_in_1.r2m" />
+		<sound id="sound_dut_1" type="file:reports/2012_05_14_09_27_40/dut_recording_spectrum/dut_in_1.r2m" />
+		<sound id="sound_host_2" type="file:reports/2012_05_14_09_27_40/dut_recording_spectrum/host_in_2.r2m" />
+		<sound id="sound_dut_2" type="file:reports/2012_05_14_09_27_40/dut_recording_spectrum/dut_in_2.r2m" />
+		<sound id="sound_host_3" type="file:reports/2012_05_14_09_27_40/dut_recording_spectrum/host_in_3.r2m" />
+		<sound id="sound_dut_3" type="file:reports/2012_05_14_09_27_40/dut_recording_spectrum/dut_in_3.r2m" />
+		<sound id="sound_host_4" type="file:reports/2012_05_14_09_27_40/dut_recording_spectrum/host_in_4.r2m" />
+		<sound id="sound_dut_4" type="file:reports/2012_05_14_09_27_40/dut_recording_spectrum/dut_in_4.r2m" />
+	</setup>
+	<action>
+		<sequential repeat="5" index="k">
+			<!-- input: host record, device record, samping rate, low frequency in Hz, high frequency in Hz, allowed error for pass in smaller side, allowed error in bigger side%, output: min value in lower side calculated normalized to 1.0, max value in higher side, calculated TF in mannitude only between low f to high f -->
+			<process method="script:check_spectrum" input="id:sound_host_$k,id:sound_dut_$k,consti:44100,consti:200,consti:4000,constf:50.0,constf:100.0" output="val:min_val_$k,val:max_val_$k,id:tf_$k" />
+		</sequential>
+	</action>
+	<save report="min_val_.*,max_val_.*" />
+</case>
diff --git a/tests/tests/media/src/android/media/cts/AudioManagerTest.java b/tests/tests/media/src/android/media/cts/AudioManagerTest.java
index ff774e2..d52e699 100644
--- a/tests/tests/media/src/android/media/cts/AudioManagerTest.java
+++ b/tests/tests/media/src/android/media/cts/AudioManagerTest.java
@@ -42,22 +42,25 @@
 import android.content.Context;
 import android.media.AudioManager;
 import android.media.MediaPlayer;
+import android.os.Vibrator;
 import android.provider.Settings;
 import android.telephony.TelephonyManager;
 import android.test.AndroidTestCase;
 import android.view.SoundEffectConstants;
 
-
 public class AudioManagerTest extends AndroidTestCase {
 
     private final static int MP3_TO_PLAY = R.raw.testmp3;
     private final static long TIME_TO_PLAY = 2000;
     private AudioManager mAudioManager;
+    private boolean mHasVibrator;
 
     @Override
     protected void setUp() throws Exception {
         super.setUp();
         mAudioManager = (AudioManager) mContext.getSystemService(Context.AUDIO_SERVICE);
+        Vibrator vibrator = (Vibrator) mContext.getSystemService(Context.VIBRATOR_SERVICE);
+        mHasVibrator = (vibrator != null) && vibrator.hasVibrator();
     }
 
     public void testMicrophoneMute() throws Exception {
@@ -167,17 +170,18 @@
     public void testVibrateNotification() throws Exception {
         // VIBRATE_SETTING_ON
         mAudioManager.setVibrateSetting(VIBRATE_TYPE_NOTIFICATION, VIBRATE_SETTING_ON);
-        assertEquals(VIBRATE_SETTING_ON,
+        assertEquals(mHasVibrator ? VIBRATE_SETTING_ON : VIBRATE_SETTING_OFF,
                 mAudioManager.getVibrateSetting(VIBRATE_TYPE_NOTIFICATION));
         mAudioManager.setRingerMode(RINGER_MODE_NORMAL);
-        assertTrue(mAudioManager.shouldVibrate(VIBRATE_TYPE_NOTIFICATION));
+        assertEquals(mHasVibrator, mAudioManager.shouldVibrate(VIBRATE_TYPE_NOTIFICATION));
 
         mAudioManager.setRingerMode(RINGER_MODE_SILENT);
         assertFalse(mAudioManager.shouldVibrate(VIBRATE_TYPE_NOTIFICATION));
 
         mAudioManager.setRingerMode(RINGER_MODE_VIBRATE);
-        assertEquals(RINGER_MODE_VIBRATE, mAudioManager.getRingerMode());
-        assertTrue(mAudioManager.shouldVibrate(VIBRATE_TYPE_NOTIFICATION));
+        assertEquals(mHasVibrator ? RINGER_MODE_VIBRATE : RINGER_MODE_SILENT,
+                mAudioManager.getRingerMode());
+        assertEquals(mHasVibrator, mAudioManager.shouldVibrate(VIBRATE_TYPE_NOTIFICATION));
 
         // VIBRATE_SETTING_OFF
         mAudioManager.setVibrateSetting(VIBRATE_TYPE_NOTIFICATION, VIBRATE_SETTING_OFF);
@@ -190,13 +194,14 @@
         assertFalse(mAudioManager.shouldVibrate(VIBRATE_TYPE_NOTIFICATION));
 
         mAudioManager.setRingerMode(RINGER_MODE_VIBRATE);
-        assertEquals(RINGER_MODE_VIBRATE, mAudioManager.getRingerMode());
+        assertEquals(mHasVibrator ? RINGER_MODE_VIBRATE : RINGER_MODE_SILENT,
+                mAudioManager.getRingerMode());
         assertFalse(mAudioManager.shouldVibrate(VIBRATE_TYPE_NOTIFICATION));
 
         // VIBRATE_SETTING_ONLY_SILENT
         mAudioManager.setVibrateSetting(VIBRATE_TYPE_NOTIFICATION, VIBRATE_SETTING_ONLY_SILENT);
-        assertEquals(VIBRATE_SETTING_ONLY_SILENT, mAudioManager
-                .getVibrateSetting(VIBRATE_TYPE_NOTIFICATION));
+        assertEquals(mHasVibrator ? VIBRATE_SETTING_ONLY_SILENT : VIBRATE_SETTING_OFF,
+                mAudioManager.getVibrateSetting(VIBRATE_TYPE_NOTIFICATION));
         mAudioManager.setRingerMode(RINGER_MODE_NORMAL);
         assertFalse(mAudioManager.shouldVibrate(VIBRATE_TYPE_NOTIFICATION));
 
@@ -204,34 +209,37 @@
         assertFalse(mAudioManager.shouldVibrate(VIBRATE_TYPE_NOTIFICATION));
 
         mAudioManager.setRingerMode(RINGER_MODE_VIBRATE);
-        assertEquals(RINGER_MODE_VIBRATE, mAudioManager.getRingerMode());
-        assertTrue(mAudioManager.shouldVibrate(VIBRATE_TYPE_NOTIFICATION));
+        assertEquals(mHasVibrator ? RINGER_MODE_VIBRATE : RINGER_MODE_SILENT,
+                mAudioManager.getRingerMode());
+        assertEquals(mHasVibrator, mAudioManager.shouldVibrate(VIBRATE_TYPE_NOTIFICATION));
 
         // VIBRATE_TYPE_NOTIFICATION
         mAudioManager.setVibrateSetting(VIBRATE_TYPE_NOTIFICATION, VIBRATE_SETTING_ON);
-        assertEquals(VIBRATE_SETTING_ON,
+        assertEquals(mHasVibrator ? VIBRATE_SETTING_ON : VIBRATE_SETTING_OFF,
                 mAudioManager.getVibrateSetting(VIBRATE_TYPE_NOTIFICATION));
         mAudioManager.setVibrateSetting(VIBRATE_TYPE_NOTIFICATION, VIBRATE_SETTING_OFF);
         assertEquals(VIBRATE_SETTING_OFF, mAudioManager
                 .getVibrateSetting(VIBRATE_TYPE_NOTIFICATION));
         mAudioManager.setVibrateSetting(VIBRATE_TYPE_NOTIFICATION, VIBRATE_SETTING_ONLY_SILENT);
-        assertEquals(VIBRATE_SETTING_ONLY_SILENT,
+        assertEquals(mHasVibrator ? VIBRATE_SETTING_ONLY_SILENT : VIBRATE_SETTING_OFF,
                 mAudioManager.getVibrateSetting(VIBRATE_TYPE_NOTIFICATION));
     }
 
     public void testVibrateRinger() throws Exception {
         // VIBRATE_TYPE_RINGER
         mAudioManager.setVibrateSetting(VIBRATE_TYPE_RINGER, VIBRATE_SETTING_ON);
-        assertEquals(VIBRATE_SETTING_ON, mAudioManager.getVibrateSetting(VIBRATE_TYPE_RINGER));
+        assertEquals(mHasVibrator ? VIBRATE_SETTING_ON : VIBRATE_SETTING_OFF,
+                mAudioManager.getVibrateSetting(VIBRATE_TYPE_RINGER));
         mAudioManager.setRingerMode(RINGER_MODE_NORMAL);
-        assertTrue(mAudioManager.shouldVibrate(VIBRATE_TYPE_RINGER));
+        assertEquals(mHasVibrator, mAudioManager.shouldVibrate(VIBRATE_TYPE_RINGER));
 
         mAudioManager.setRingerMode(RINGER_MODE_SILENT);
         assertFalse(mAudioManager.shouldVibrate(VIBRATE_TYPE_RINGER));
 
         mAudioManager.setRingerMode(RINGER_MODE_VIBRATE);
-        assertEquals(RINGER_MODE_VIBRATE, mAudioManager.getRingerMode());
-        assertTrue(mAudioManager.shouldVibrate(VIBRATE_TYPE_RINGER));
+        assertEquals(mHasVibrator ? RINGER_MODE_VIBRATE : RINGER_MODE_SILENT,
+                mAudioManager.getRingerMode());
+        assertEquals(mHasVibrator, mAudioManager.shouldVibrate(VIBRATE_TYPE_RINGER));
 
         // VIBRATE_SETTING_OFF
         mAudioManager.setVibrateSetting(VIBRATE_TYPE_RINGER, VIBRATE_SETTING_OFF);
@@ -243,7 +251,8 @@
         assertFalse(mAudioManager.shouldVibrate(VIBRATE_TYPE_RINGER));
 
         mAudioManager.setRingerMode(RINGER_MODE_VIBRATE);
-        assertEquals(RINGER_MODE_VIBRATE, mAudioManager.getRingerMode());
+        assertEquals(mHasVibrator ? RINGER_MODE_VIBRATE : RINGER_MODE_SILENT,
+                mAudioManager.getRingerMode());
         // Note: as of Froyo, if VIBRATE_TYPE_RINGER is set to OFF, it will
         // not vibrate, even in RINGER_MODE_VIBRATE. This allows users to
         // disable the vibration for incoming calls only.
@@ -251,8 +260,8 @@
 
         // VIBRATE_SETTING_ONLY_SILENT
         mAudioManager.setVibrateSetting(VIBRATE_TYPE_RINGER, VIBRATE_SETTING_ONLY_SILENT);
-        assertEquals(VIBRATE_SETTING_ONLY_SILENT, mAudioManager
-                .getVibrateSetting(VIBRATE_TYPE_RINGER));
+        assertEquals(mHasVibrator ? VIBRATE_SETTING_ONLY_SILENT : VIBRATE_SETTING_OFF,
+                mAudioManager.getVibrateSetting(VIBRATE_TYPE_RINGER));
         mAudioManager.setRingerMode(RINGER_MODE_NORMAL);
         assertFalse(mAudioManager.shouldVibrate(VIBRATE_TYPE_RINGER));
 
@@ -260,16 +269,18 @@
         assertFalse(mAudioManager.shouldVibrate(VIBRATE_TYPE_RINGER));
 
         mAudioManager.setRingerMode(RINGER_MODE_VIBRATE);
-        assertEquals(RINGER_MODE_VIBRATE, mAudioManager.getRingerMode());
-        assertTrue(mAudioManager.shouldVibrate(VIBRATE_TYPE_RINGER));
+        assertEquals(mHasVibrator ? RINGER_MODE_VIBRATE : RINGER_MODE_SILENT,
+                mAudioManager.getRingerMode());
+        assertEquals(mHasVibrator, mAudioManager.shouldVibrate(VIBRATE_TYPE_RINGER));
 
         // VIBRATE_TYPE_NOTIFICATION
         mAudioManager.setVibrateSetting(VIBRATE_TYPE_RINGER, VIBRATE_SETTING_ON);
-        assertEquals(VIBRATE_SETTING_ON, mAudioManager.getVibrateSetting(VIBRATE_TYPE_RINGER));
+        assertEquals(mHasVibrator ? VIBRATE_SETTING_ON : VIBRATE_SETTING_OFF,
+                mAudioManager.getVibrateSetting(VIBRATE_TYPE_RINGER));
         mAudioManager.setVibrateSetting(VIBRATE_TYPE_RINGER, VIBRATE_SETTING_OFF);
         assertEquals(VIBRATE_SETTING_OFF, mAudioManager.getVibrateSetting(VIBRATE_TYPE_RINGER));
         mAudioManager.setVibrateSetting(VIBRATE_TYPE_RINGER, VIBRATE_SETTING_ONLY_SILENT);
-        assertEquals(VIBRATE_SETTING_ONLY_SILENT,
+        assertEquals(mHasVibrator ? VIBRATE_SETTING_ONLY_SILENT : VIBRATE_SETTING_OFF,
                 mAudioManager.getVibrateSetting(VIBRATE_TYPE_RINGER));
     }
 
@@ -281,7 +292,8 @@
         assertEquals(RINGER_MODE_SILENT, mAudioManager.getRingerMode());
 
         mAudioManager.setRingerMode(RINGER_MODE_VIBRATE);
-        assertEquals(RINGER_MODE_VIBRATE, mAudioManager.getRingerMode());
+        assertEquals(mHasVibrator ? RINGER_MODE_VIBRATE : RINGER_MODE_SILENT,
+                mAudioManager.getRingerMode());
     }
 
     public void testVolume() throws Exception {
@@ -291,19 +303,14 @@
                           AudioManager.STREAM_VOICE_CALL,
                           AudioManager.STREAM_RING };
 
-        // set ringer mode to back normal to not interfere with volume tests
-        mAudioManager.setRingerMode(RINGER_MODE_NORMAL);
-
-        TelephonyManager tm =
-            (TelephonyManager)mContext.getSystemService(Context.TELEPHONY_SERVICE);
-        //FIXME: use TelephonyManager.isVoiceCapable() when public
-        boolean voiceCapable = tm.getPhoneType() != TelephonyManager.PHONE_TYPE_NONE;
-
         mAudioManager.adjustVolume(ADJUST_RAISE, 0);
         mAudioManager.adjustSuggestedStreamVolume(
                 ADJUST_LOWER, USE_DEFAULT_STREAM_TYPE, 0);
 
         for (int i = 0; i < streams.length; i++) {
+            // set ringer mode to back normal to not interfere with volume tests
+            mAudioManager.setRingerMode(RINGER_MODE_NORMAL);
+
             int maxVolume = mAudioManager.getStreamMaxVolume(streams[i]);
 
             mAudioManager.setStreamVolume(streams[i], 1, 0);
@@ -318,23 +325,15 @@
 
             // volume lower
             mAudioManager.setStreamVolume(streams[i], maxVolume, 0);
-            for (int k = maxVolume; k > 1; k--) {
+            for (int k = maxVolume; k > 0; k--) {
                 mAudioManager.adjustStreamVolume(streams[i], ADJUST_LOWER, 0);
                 assertEquals(k - 1, mAudioManager.getStreamVolume(streams[i]));
             }
-            // on voice capable devices, ring and notification volumes cannot be set to 0
-            // by continous press on volume minus key
-            // simulate volume key release
-            mAudioManager.adjustStreamVolume(streams[i], ADJUST_SAME, FLAG_ALLOW_RINGER_MODES);
-            mAudioManager.adjustStreamVolume(streams[i], ADJUST_LOWER, 0);
-            assertEquals(0, mAudioManager.getStreamVolume(streams[i]));
 
-            // set ringer mode to back normal to not interfere with volume tests
-            mAudioManager.setRingerMode(RINGER_MODE_NORMAL);
-
+            mAudioManager.adjustStreamVolume(streams[i], ADJUST_SAME, 0);
             // volume raise
-            mAudioManager.setStreamVolume(streams[i], 0, 0);
-            for (int k = 0; k < maxVolume; k++) {
+            mAudioManager.setStreamVolume(streams[i], 1, 0);
+            for (int k = 1; k < maxVolume; k++) {
                 mAudioManager.adjustStreamVolume(streams[i], ADJUST_RAISE, 0);
                 assertEquals(1 + k, mAudioManager.getStreamVolume(streams[i]));
             }
diff --git a/tests/tests/os/src/android/os/cts/BuildVersionTest.java b/tests/tests/os/src/android/os/cts/BuildVersionTest.java
index 6cb09bb..f001168 100644
--- a/tests/tests/os/src/android/os/cts/BuildVersionTest.java
+++ b/tests/tests/os/src/android/os/cts/BuildVersionTest.java
@@ -29,8 +29,8 @@
 
     private static final String LOG_TAG = "BuildVersionTest";
     private static final Set<String> EXPECTED_RELEASES =
-            new HashSet<String>(Arrays.asList("4.0.3", "4.0.4"));
-    private static final int EXPECTED_SDK = 15;
+            new HashSet<String>(Arrays.asList("4.1"));
+    private static final int EXPECTED_SDK = 16;
 
     @SuppressWarnings("deprecation")
     public void testReleaseVersion() {
diff --git a/tests/tests/security/src/android/security/cts/KernelSettingsTest.java b/tests/tests/security/src/android/security/cts/KernelSettingsTest.java
index 7198241..1e6d384 100644
--- a/tests/tests/security/src/android/security/cts/KernelSettingsTest.java
+++ b/tests/tests/security/src/android/security/cts/KernelSettingsTest.java
@@ -58,6 +58,17 @@
         }
     }
 
+    /**
+     * setuid programs should not be dumpable.
+     */
+    public void testSetuidDumpable() throws IOException {
+        try {
+            assertEquals("0", getFile("/proc/sys/fs/suid_dumpable"));
+        } catch (FileNotFoundException e) {
+            // Odd. The file doesn't exist... Assume we're ok.
+        }
+    }
+
     private String getFile(String filename) throws IOException {
         BufferedReader in = null;
         try {
diff --git a/tests/tests/view/src/android/view/cts/ViewTest.java b/tests/tests/view/src/android/view/cts/ViewTest.java
index 94aed3f..db20614 100644
--- a/tests/tests/view/src/android/view/cts/ViewTest.java
+++ b/tests/tests/view/src/android/view/cts/ViewTest.java
@@ -3356,6 +3356,11 @@
         public void childAccessibilityStateChanged(View child) {
 
         }
+
+        @Override
+        public View findViewToTakeAccessibilityFocusFromHover(View child, View descendant) {
+            return null;
+        }
     }
 
     private final class OnCreateContextMenuListenerImpl implements OnCreateContextMenuListener {