am 643e8476: Merge "Fixes Issue ID: 3396697" into honeycomb

* commit '643e8476e1b9da93a06d073797863298ae268393':
  Fixes Issue ID: 3396697

9 files changed, 9594 insertions, 0 deletions

diff --git a/media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/MediaFrameworkStressTestRunner.java b/media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/MediaFrameworkStressTestRunner.java
new file mode 100755
index 0000000..cfcc12f
--- /dev/null
+++ b/media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/MediaFrameworkStressTestRunner.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright (C) 2011 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.
+ */
+
+package com.android.mediaframeworktest;
+
+import com.android.mediaframeworktest.stress.MediaPlayerStressTest;
+import com.android.mediaframeworktest.stress.VideoEditorStressTest;
+import junit.framework.TestSuite;
+import android.test.InstrumentationTestRunner;
+import android.test.InstrumentationTestSuite;
+
+/**
+ * Instrumentation Test Runner for all MediaPlayer tests.
+ *
+ * Running all tests:
+ *
+ * adb shell am instrument \
+ *   -w com.android.smstests.MediaPlayerInstrumentationTestRunner
+ */
+
+public class MediaFrameworkStressTestRunner extends InstrumentationTestRunner {
+
+
+  @Override
+  public TestSuite getAllTests() {
+      TestSuite suite = new InstrumentationTestSuite(this);
+        suite.addTestSuite(MediaPlayerStressTest.class);
+      /** Video Editor Stress Test cases*/
+        suite.addTestSuite(VideoEditorStressTest.class);
+      return suite;
+  }
+
+  @Override
+  public ClassLoader getLoader() {
+      return MediaFrameworkTestRunner.class.getClassLoader();
+  }
+}
+
diff --git a/media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/VideoEditorHelper.java b/media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/VideoEditorHelper.java
new file mode 100755
index 0000000..dd7c4c6
--- /dev/null
+++ b/media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/VideoEditorHelper.java
@@ -0,0 +1,479 @@
+/*
+ * Copyright (C) 2011 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.
+ */
+
+package com.android.mediaframeworktest;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.text.SimpleDateFormat;
+import java.util.Date;
+import java.util.Random;
+
+import junit.framework.Assert;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
+import android.media.videoeditor.AudioTrack;
+import android.media.videoeditor.EffectColor;
+import android.media.videoeditor.MediaImageItem;
+import android.media.videoeditor.MediaItem;
+import android.media.videoeditor.MediaVideoItem;
+import android.media.videoeditor.OverlayFrame;
+import android.media.videoeditor.TransitionAlpha;
+import android.media.videoeditor.TransitionCrossfade;
+import android.media.videoeditor.TransitionFadeBlack;
+import android.media.videoeditor.TransitionSliding;
+import android.media.videoeditor.VideoEditor;
+import android.media.videoeditor.VideoEditorFactory;
+import android.util.Log;
+import android.os.Environment;
+
+/**
+ * This class has the names of the all the activity name and variables in the
+ * instrumentation test.
+ */
+public class VideoEditorHelper extends Assert {
+
+    private final String TAG = "VideoEditorMediaNames";
+
+    public VideoEditorHelper() {
+
+    }
+
+    public static final String PROJECT_LOCATION_COMMON =
+        Environment.getExternalStorageDirectory().toString() + "/";
+
+    public static final String INPUT_FILE_PATH_COMMON = PROJECT_LOCATION_COMMON +
+        "media_api/videoeditor/";
+
+    // -----------------------------------------------------------------
+    // HELPER METHODS
+    // -----------------------------------------------------------------
+
+    /**
+     * This method creates an object of VideoEditor
+     *
+     * @param projectPath the directory where all files related to project will
+     *            be stored
+     * @param className The class which implements the VideoEditor Class
+     * @return the object of VideoEditor
+     */
+    public VideoEditor createVideoEditor(String projectPath) {
+        VideoEditor mVideoEditor = null;
+        try {
+            mVideoEditor = VideoEditorFactory.create(projectPath);
+            assertNotNull("VideoEditor", mVideoEditor);
+        } catch (Exception e) {
+            fail("Unable to create Video Editor");
+        }
+        return mVideoEditor;
+    }
+
+    /**
+     *This method deletes the VideoEditor object created using
+     * createVideoEditor method
+     *
+     * @param videoEditor the VideoEditor object which needs to be cleaned up
+     */
+    public void destroyVideoEditor(VideoEditor videoEditor) {
+        // Release VideoEditor
+        if (videoEditor != null) {
+            try {
+                videoEditor.release();
+            } catch (Exception e) {
+                fail("Unable to destory Video Editor");
+            }
+        }
+    }
+
+    /**
+     *This Method checks the Range in "RangePercent" (say 10)
+     *
+     * @param int Expected data
+     * @param actual data
+     * @return boolean flag which confirms the range matching
+     */
+    public boolean checkRange(long expected, long actual, long rangePercent) {
+        long range = 0;
+        range = (100 * actual) / expected;
+
+        Log.i("checkRange", "Range = " + range);
+        if ((range > (100 - rangePercent)) && (range < (100 + rangePercent))) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     *This Method Creates a Bitmap with the given input file
+     *
+     * @param file the Input whose Bitmap has top be extracted
+     * @return an Object of EffectColor
+     */
+    public Bitmap getBitmap(String file, int width, int height) throws IOException {
+        assertNotNull("Bitmap File is Null", file);
+        FileInputStream inputStream = null;
+        Bitmap overlayBmp = null;
+        if (!new File(file).exists())
+            throw new IOException("File not Found " + file);
+        try {
+            final BitmapFactory.Options dbo = new BitmapFactory.Options();
+            dbo.inJustDecodeBounds = true;
+            dbo.outWidth = width;
+            dbo.outHeight = height;
+            File flPtr = new File(file);
+            inputStream = new FileInputStream(flPtr);
+            final Bitmap srcBitmap = BitmapFactory.decodeStream(inputStream);
+            overlayBmp = Bitmap.createBitmap(srcBitmap);
+            assertNotNull("Bitmap 1", srcBitmap);
+            assertNotNull("Bitmap 2", overlayBmp);
+            inputStream.close();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return overlayBmp;
+    }
+
+    /**
+     *This Method Create a Media Video Item with the specified params
+     *
+     * @return an Object of MediaVideoItem
+     */
+    public MediaVideoItem createMediaItem(VideoEditor videoEditor,
+        String MediaId, String filename, int renderingMode) {
+        MediaVideoItem mvi = null;
+        try {
+            mvi = new MediaVideoItem(videoEditor, MediaId, filename,
+                renderingMode);
+            assertNotNull("Can not create an object of MediaVideoItem", mvi);
+        } catch (IllegalArgumentException e) {
+            throw new IllegalArgumentException
+                ("Can not create an object of Media Video Item with file name = "
+                    + filename + " Issue = " + e.toString());
+        } catch (IOException e) {
+            assertTrue
+                ("Can not create an object of Media Video Item with file name = "
+                    + filename + " Issue = " + e.toString(), false);
+        }
+        return mvi;
+    }
+
+    /**
+     *This Method Create a Media Image Item with the specified params
+     *
+     * @return an Object of MediaImageItem
+     */
+    public MediaImageItem createMediaItem(VideoEditor videoEditor,
+        String MediaId, String filename, long duration, int renderingMode) {
+        MediaImageItem mii = null;
+        try {
+            mii = new MediaImageItem(videoEditor, MediaId, filename, duration,
+                renderingMode);
+            assertNotNull("Can not create an object of MediaImageItem", mii);
+
+        } catch (IllegalArgumentException e) {
+            assertTrue("Can not create an object of Media Image with file name = "
+                + filename + " Issue = " + e.toString(), false);
+        } catch (IOException e) {
+            assertTrue("Can not create an object of Media Image with file name = "
+                + filename + " Issue = " + e.toString(), false);
+        }
+        return mii;
+    }
+
+    /**
+     *This Method Create a Effect with the specified params
+     *
+     * @return an Object of EffectColor
+     */
+    public EffectColor createEffectItem(MediaItem mediaItem, String effectId,
+        long startTime, long duration, int effectType, int colorType) {
+        EffectColor effectonMVI = null;
+        effectonMVI = new EffectColor(mediaItem, effectId, startTime,
+            duration, effectType, colorType);
+        return effectonMVI;
+    }
+
+    /**
+     *This Method creates object of Type Transition Cross fade
+     *
+     * @return TransitionCrossfade object
+     */
+    public TransitionCrossfade createTCrossFade(String transitionId,
+        MediaItem afterMediaItem, MediaItem beforeMediaItem, long durationMs,
+        int behavior) {
+        Log.i("TransitionCrossfade Details === ", "Transid ID = " + transitionId +
+            " Duration= " + durationMs + " Behaviour " + behavior);
+
+        TransitionCrossfade transitionCF = null;
+            transitionCF = new TransitionCrossfade(transitionId, afterMediaItem,
+                beforeMediaItem, durationMs, behavior);
+        return transitionCF;
+    }
+
+    /**
+     *This Method creates object of Type TransitionFadeBlack
+     *
+     * @return TransitionFadeBlack object
+     */
+    public TransitionFadeBlack createTFadeBlack(String transitionId,
+        MediaItem afterMediaItem, MediaItem beforeMediaItem, long durationMs,
+        int behavior) {
+        TransitionFadeBlack transitionFB = null;
+
+        transitionFB = new TransitionFadeBlack(transitionId, afterMediaItem,
+            beforeMediaItem, durationMs, behavior);
+        return transitionFB;
+    }
+
+    /**
+     *This Method creates object of Type TransitionSliding
+     *
+     * @return TransitionSliding object
+     */
+    public TransitionSliding createTSliding(String transitionId,
+        MediaItem afterMediaItem, MediaItem beforeMediaItem, long durationMs,
+        int behavior, int direction) {
+        TransitionSliding transSlide = null;
+            transSlide = new TransitionSliding(transitionId, afterMediaItem,
+                beforeMediaItem, durationMs, behavior, direction);
+        return transSlide;
+    }
+
+    /**
+     *This Method creates object of Type TranistionAlpha
+     *
+     * @return TranistionAlpha object
+     */
+
+    public TransitionAlpha createTAlpha(String transitionId,
+        MediaItem afterMediaItem, MediaItem beforeMediaItem, long durationMs,
+        int behavior, String maskFilename, int blendingPercent, boolean invert) {
+        TransitionAlpha transA = null;
+            transA = new TransitionAlpha(transitionId, afterMediaItem,
+                beforeMediaItem, durationMs, behavior, maskFilename,
+                blendingPercent, invert);
+        return transA;
+    }
+
+    /**
+     *This Method creates object of Type OverlayFrame
+     *
+     * @return OverlayFrame object
+     */
+
+    public OverlayFrame createOverlay(MediaItem mediaItem, String overlayId,
+        Bitmap bitmap, long startTimeMs, long durationMs) {
+        OverlayFrame overLayFrame = null;
+        overLayFrame = new OverlayFrame(mediaItem, overlayId, bitmap,
+                startTimeMs, durationMs);
+        return overLayFrame;
+    }
+
+    /**
+     *This Method creates object of Type AudioTrack
+     *
+     * @return OverlayFrame object
+     */
+    public AudioTrack createAudio(VideoEditor videoEditor, String audioTrackId,
+        String filename) {
+        AudioTrack audio = null;
+        try {
+            audio = new AudioTrack(videoEditor, audioTrackId, filename);
+            assertNotNull("Cant not create an object of an  AudioTrack " +
+                audioTrackId, audio);
+        } catch (IllegalArgumentException e) {
+            assertTrue("Can not create object of an AudioTrack " +
+                audioTrackId + " Issue = " + e.toString(), false);
+        } catch (IOException e) {
+            assertTrue("Can not create object of an AudioTrack " +
+                audioTrackId + " Issue = " + e.toString(), false);
+        }
+        return audio;
+    }
+
+    /**
+     *This Method validates the Exported Movie,as per the specified params
+     * during Export
+     */
+
+    public void validateExport(VideoEditor videoEditor, String fileName,
+        int export_height, int startTime, long endTime, int vCodec, int aCodec) {
+        File tempFile = new File(fileName);
+        assertEquals("Exported FileName", tempFile.exists(), true);
+        final MediaVideoItem mvi = createMediaItem(videoEditor, "m1", fileName,
+            MediaItem.RENDERING_MODE_BLACK_BORDER);
+
+        Log.i(TAG, "VideoCodec for file = " + fileName +
+            "\tExpected Video Codec = " + vCodec + "\tActual Video Codec = " +
+            mvi.getVideoType());
+        assertEquals("Export: Video Codec Mismatch for file = " + fileName +
+            "\t<expected> " + vCodec + "\t<actual> " + mvi.getVideoType(),
+            vCodec, mvi.getVideoType());
+
+        Log.i(TAG, "Height for file = " + fileName + "\tExpected Height = " +
+            export_height + "\tActual VideoHeight = " + mvi.getHeight());
+        assertEquals("Export height Mismatch for file " + fileName +
+            "\t<expected> " + export_height + "\t<actual> " + mvi.getHeight(),
+             export_height, mvi.getHeight());
+        if (startTime == 0) {
+            if (endTime != 0) {
+                Log.i(TAG, "TimeLine Expected = " + (startTime + endTime) +
+                    "\t VideoTime= " + mvi.getTimelineDuration());
+                assertTrue("Timeline Duration Mismatch for file " + fileName +
+                    "<expected> " + (startTime + endTime) + "\t<actual> " +
+                    mvi.getTimelineDuration(), checkRange((startTime +
+                        endTime), mvi.getTimelineDuration(), 10));
+            }
+        } else {
+            Log.i(TAG, "TimeLine Expected = " + (endTime - startTime) +
+                "\t VideoTime= " + mvi.getTimelineDuration());
+            assertTrue("Timeline Duration Mismatch for file " + fileName +
+                "<expected> " + (endTime - startTime) + "\t<actual> " +
+                mvi.getTimelineDuration(), checkRange((endTime -
+                    startTime), (int)mvi.getTimelineDuration(), 10));
+        }
+    }
+
+    /**
+     * @param videoEditor
+     * @param fileName
+     * @param export_bitrate
+     * @param export_height
+     * @param startTime
+     * @param endTime
+     * @param vCodec
+     * @param aCodec
+     */
+    public void validateExport(VideoEditor videoEditor, String fileName,
+        int export_height, int startTime, int endTime, int vCodec, int aCodec) {
+        File tempFile = new File(fileName);
+        assertEquals("Exported FileName", tempFile.exists(), true);
+        final MediaVideoItem mvi = createMediaItem(videoEditor, "m1", fileName,
+            MediaItem.RENDERING_MODE_BLACK_BORDER);
+        Log.i(TAG, "VideoCodec for file = " + fileName +
+            "\tExpected Video Codec = " + vCodec + "\tActual Video Codec = " +
+            mvi.getVideoType());
+        assertEquals("Export: Video Codec Mismatch for file = " + fileName +
+            "\t<expected> " + vCodec + "\t<actual> " + mvi.getVideoType(),
+            vCodec, mvi.getVideoType());
+
+        Log.i(TAG, "AudioCodec for file = " + fileName +
+            "\tExpected Audio Codec = " + aCodec + "\tActual Audio Codec = " +
+            mvi.getAudioType());
+        assertEquals("Export: Audio Codec Mismatch for file = " + fileName +
+            "\t<expected> " + aCodec + "\t<actual> " + mvi.getAudioType(),
+            aCodec, mvi.getAudioType());
+
+        Log.i(TAG, "Height for file = " + fileName + "\tExpected Height = " +
+            export_height + "\tActual VideoHeight = " + mvi.getHeight());
+        assertEquals("Export: height Mismatch for file " + fileName +
+            "\t<expected> " + export_height + "\t<actual> " + mvi.getHeight(),
+            export_height, mvi.getHeight());
+        if (startTime == 0) {
+            if (endTime != 0) {
+                Log.i(TAG, "TimeLine Expected = " + (startTime + endTime) +
+                    "\t VideoTime= " + mvi.getTimelineDuration());
+                assertTrue("Export :Timeline Duration Mismatch for file " +
+                    fileName + "<expected> " + (startTime + endTime) +
+                    "\t<actual> " + mvi.getTimelineDuration(),
+                    checkRange((startTime + endTime), mvi.getTimelineDuration(), 10));
+            }
+        } else {
+            Log.i(TAG, "TimeLine Expected = " + (endTime-startTime) +
+                "\t VideoTime= " + mvi.getTimelineDuration());
+            assertTrue("Timeline Duration Mismatch for file " + fileName +
+                "<expected> " + (endTime - startTime) + "\t<actual> " +
+                mvi.getTimelineDuration(), checkRange((endTime -
+                    startTime), mvi.getTimelineDuration(), 10));
+        }
+    }
+
+    /**
+     * Check file and deletes it.
+     *
+     * @param filename
+     */
+    public void checkDeleteExistingFile(String filename) {
+        Log.i(TAG, ">>>>>>>>>>>>>>>>>>checkDeleteExistingFile  = " + filename);
+        if (filename != null) {
+            File temp = new File(filename);
+            if (temp != null && temp.exists()) {
+                temp.delete();
+            }
+        }
+    }
+
+    /**
+     * This method creates a Directory and filename
+     *
+     * @param location This is path where the file is to be created
+     *            "/sdcard/Output/"
+     * @return Path in form of /sdcard/Output/200910100000
+     */
+    public String createRandomFile(String location) {
+        Random randomGenerator = new Random();
+        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyyMMddHHmmssS");
+        Date date = new Date();
+        final String filePath = location + dateFormat.format(date) +
+            randomGenerator.nextInt(10);
+        Log.i(TAG, ">>>>>>>>>>>>>>>>createRandomFile  Location= " + location +
+            "\t FilePath = " + filePath);
+        return filePath;
+    }
+
+    /**
+     * This method recursively deletes all the file and directory
+     *
+     * @param directory where the files are located Example = "/sdcard/Input"
+     * @return boolean True if deletion is successful else False
+     */
+    public boolean deleteProject(File directory) {
+        Log.i(TAG, ">>>>>>>>>>>>>>>>>>>>>>>>deleteProject  directory= " +
+            directory.toString());
+        if (directory.isDirectory()) {
+            String[] filesInDirecory = directory.list();
+            for (int i = 0; i < filesInDirecory.length; i++) {
+                boolean success = deleteProject(new File(directory,
+                    filesInDirecory[i]));
+                if (!success) {
+                    return false;
+                }
+            }
+        }
+        return directory.delete();
+    }
+
+    /**
+     * This method compares the array of Integer from 0 - 100
+     *
+     * @param data set of integer values received as progress
+     * @return true if sucess else false
+     */
+    public boolean checkProgressCBValues(int[] data) {
+        boolean retFlag = false;
+        for (int i = 0; i < 100; i++) {
+            if (data[i] == 100) {
+                retFlag = true;
+                break;
+            } else {
+                retFlag = false;
+            }
+        }
+        return retFlag;
+    }
+}
diff --git a/media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/functional/MediaItemThumbnailTest.java b/media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/functional/MediaItemThumbnailTest.java
new file mode 100755
index 0000000..e5641b1
--- /dev/null
+++ b/media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/functional/MediaItemThumbnailTest.java
@@ -0,0 +1,954 @@
+/*
+ * Copyright (C) 2011 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.
+ */
+
+
+package com.android.mediaframeworktest.functional;
+
+import java.io.File;
+import java.io.IOException;
+
+import android.graphics.Bitmap;
+import android.media.videoeditor.MediaImageItem;
+import android.media.videoeditor.MediaItem;
+import android.media.videoeditor.MediaVideoItem;
+import android.media.videoeditor.VideoEditor;
+import android.os.Environment;
+import android.test.ActivityInstrumentationTestCase;
+import android.test.suitebuilder.annotation.LargeTest;
+import com.android.mediaframeworktest.MediaFrameworkTest;
+import com.android.mediaframeworktest.VideoEditorHelper;
+
+public class MediaItemThumbnailTest extends
+    ActivityInstrumentationTestCase<MediaFrameworkTest> {
+    private final String TAG = "MediaItemThumbailTest";
+
+    private final String PROJECT_LOCATION = VideoEditorHelper.PROJECT_LOCATION_COMMON;
+
+    private final String INPUT_FILE_PATH = VideoEditorHelper.INPUT_FILE_PATH_COMMON;
+
+    private VideoEditor mVideoEditor;
+
+    private VideoEditorHelper mVideoEditorHelper;
+
+    public MediaItemThumbnailTest() {
+        super("com.android.mediaframeworktest", MediaFrameworkTest.class);
+    }
+
+    @Override
+    protected void setUp() throws Exception {
+        // setup for each test case.
+        super.setUp();
+        mVideoEditorHelper = new VideoEditorHelper();
+        // Create a random String which will be used as project path, where all
+        // project related files will be stored.
+        final String projectPath = mVideoEditorHelper.
+            createRandomFile(PROJECT_LOCATION);
+        mVideoEditor = mVideoEditorHelper.createVideoEditor(projectPath);
+    }
+
+    @Override
+    protected void tearDown() throws Exception {
+        mVideoEditorHelper.destroyVideoEditor(mVideoEditor);
+        // Clean the directory created as project path
+        mVideoEditorHelper.deleteProject(new File(mVideoEditor.getPath()));
+        System.gc();
+        super.tearDown();
+    }
+
+    protected void validateThumbnail(Bitmap thumbNailBmp, int outWidth,
+        int outHeight) throws Exception {
+        assertNotNull("Thumbnail Retrived is Null", thumbNailBmp);
+        assertEquals("Thumbnail Height", outHeight, thumbNailBmp.getHeight());
+        assertEquals("Thumbnail Width", outWidth, thumbNailBmp.getWidth());
+        thumbNailBmp.recycle();
+    }
+
+    // -----------------------------------------------------------------
+    // THUMBNAIL
+    // -----------------------------------------------------------------
+    /**
+     * To test thumbnail / frame extraction on H.263 QCIF.
+     */
+    // TODO : TC_TN_001
+    @LargeTest
+    public void testThumbnailForH263QCIF() throws Exception {
+        final String videoItemFilename = INPUT_FILE_PATH
+            + "H263_profile0_176x144_15fps_256kbps_AACLC_32kHz_128kbps_s_0_26.3gp";
+        final int atTime = 0;
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        final MediaVideoItem mediaVideoItem =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
+                videoItemFilename, renderingMode);
+
+        final int outWidth = (mediaVideoItem.getWidth() / 2);
+        final int outHeight = mediaVideoItem.getHeight();
+
+        final Bitmap thumbNailBmp = mediaVideoItem.getThumbnail(outWidth,
+            outHeight, atTime);
+        validateThumbnail(thumbNailBmp, outWidth, outHeight);
+    }
+
+    /**
+     * To test thumbnail / frame extraction on MPEG4 VGA .
+     */
+    // TODO : TC_TN_002
+    @LargeTest
+    public void testThumbnailForMPEG4VGA() throws Exception {
+        final String videoItemFilename = INPUT_FILE_PATH +
+            "MPEG4_SP_640x480_30fps_512Kbps_0_23.3gp";
+        final int atTime = 0;
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        final MediaVideoItem mediaVideoItem =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
+                videoItemFilename, renderingMode);
+        final int outWidth = (mediaVideoItem.getWidth() / 2);
+        final int outHeight = mediaVideoItem.getHeight();
+        final Bitmap thumbNailBmp = mediaVideoItem.getThumbnail(outWidth,
+            outHeight, atTime);
+        validateThumbnail(thumbNailBmp, outWidth, outHeight);
+    }
+
+    /**
+     * To test thumbnail / frame extraction on MPEG4 NTSC.
+     */
+    // TODO : TC_TN_003
+    @LargeTest
+    public void testThumbnailForMPEG4NTSC() throws Exception {
+        final String videoItemFilename = INPUT_FILE_PATH
+            + "MPEG4_SP_720x480_30fps_280kbps_AACLC_48kHz_96kbps_s_0_21.mp4";
+        final int atTime = 0;
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        final MediaVideoItem mediaVideoItem =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
+                videoItemFilename, renderingMode);
+        final int outWidth = mediaVideoItem.getWidth() / 2;
+        final int outHeight = mediaVideoItem.getHeight() / 2;
+        final Bitmap thumbNailBmp = mediaVideoItem.getThumbnail(outWidth,
+            outHeight, atTime);
+        validateThumbnail(thumbNailBmp, outWidth, outHeight);
+    }
+
+    /**
+     * To test thumbnail / frame extraction on MPEG4 WVGA.
+     */
+    // TODO : TC_TN_004
+    @LargeTest
+    public void testThumbnailForMPEG4WVGA() throws Exception {
+
+        final String videoItemFilename = INPUT_FILE_PATH
+            + "MPEG4_SP_800x480_515kbps_15fps_AMR_NB_8KHz_12.2kbps_m_0_26.mp4";
+        final int atTime = 0;
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        final MediaVideoItem mediaVideoItem =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
+                videoItemFilename, renderingMode);
+        final int outWidth = mediaVideoItem.getWidth() * 2;
+        final int outHeight = mediaVideoItem.getHeight();
+        final Bitmap thumbNailBmp = mediaVideoItem.getThumbnail(outWidth,
+            outHeight, atTime);
+        validateThumbnail(thumbNailBmp, outWidth, outHeight);
+    }
+
+    /**
+     * To test thumbnail / frame extraction on MPEG4 QCIF.
+     */
+    // TODO : TC_TN_005
+    @LargeTest
+    public void testThumbnailForMPEG4QCIF() throws Exception {
+        final String videoItemFilename = INPUT_FILE_PATH
+            + "MPEG4_SP_176x144_30fps_256kbps_AACLC_44.1kHz_96kbps_s_1_17.3gp";
+        final int atTime = 0;
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+
+        final MediaVideoItem mediaVideoItem =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
+                videoItemFilename, renderingMode);
+        final int outWidth = mediaVideoItem.getWidth();
+        final int outHeight = mediaVideoItem.getHeight() * 2;
+        final Bitmap thumbNailBmp = mediaVideoItem.getThumbnail(outWidth,
+            outHeight, atTime);
+        validateThumbnail(thumbNailBmp, outWidth, outHeight);
+    }
+
+    /**
+     * To test thumbnail / frame extraction on H264 QCIF.
+     */
+    // TODO : TC_TN_006
+    @LargeTest
+    public void testThumbnailForH264QCIF() throws Exception {
+        final String videoItemFilename = INPUT_FILE_PATH
+            + "H264_BP_176x144_15fps_144kbps_AMRNB_8kHz_12.2kbps_m_1_17.3gp";
+
+        final int atTime = 0;
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        final MediaVideoItem mediaVideoItem =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
+                videoItemFilename, renderingMode);
+        final int outWidth = mediaVideoItem.getWidth() * 2;
+        final int outHeight = mediaVideoItem.getHeight() * 2;
+        final Bitmap thumbNailBmp = mediaVideoItem.getThumbnail(outWidth,
+            outHeight, atTime);
+        validateThumbnail(thumbNailBmp, outWidth, outHeight);
+    }
+
+    /**
+     * To test thumbnail / frame extraction on H264 VGA.
+     */
+    // TODO : TC_TN_007
+    @LargeTest
+    public void testThumbnailForH264VGA() throws Exception {
+        final String videoItemFilename = INPUT_FILE_PATH +
+            "H264_BP_640x480_30fps_192kbps_1_5.mp4";
+        final int outWidth = 32;
+        final int outHeight = 32;
+        final int atTime = 0;
+
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        final MediaVideoItem mediaVideoItem =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
+                videoItemFilename, renderingMode);
+
+        final Bitmap thumbNailBmp = mediaVideoItem.getThumbnail(outWidth,
+            outHeight, atTime);
+        validateThumbnail(thumbNailBmp, outWidth, outHeight);
+    }
+    /**
+     * To test thumbnail / frame extraction on H264 WVGA.
+     */
+    // TODO : TC_TN_008
+    @LargeTest
+    public void testThumbnailForH264WVGA() throws Exception {
+        final String videoItemFilename = INPUT_FILE_PATH +
+            "H264_BP_800x480_15fps_512kbps_AACLC_24KHz_38Kbps_s_1_17.mp4";
+        final int outWidth = 64;
+        final int outHeight = 64;
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        final MediaVideoItem mediaVideoItem =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
+                videoItemFilename, renderingMode);
+        final long atTime = mediaVideoItem.getDuration() / 2;
+        final Bitmap thumbNailBmp = mediaVideoItem.getThumbnail(outWidth,
+            outHeight, atTime);
+        validateThumbnail(thumbNailBmp, outWidth, outHeight);
+    }
+
+    /**
+     * To test thumbnail / frame extraction on H264 854x480.
+     */
+    // TODO : TC_TN_009
+    @LargeTest
+    public void testThumbnailForH264854_480() throws Exception {
+        final String videoItemFilename = INPUT_FILE_PATH
+            + "MPEG4_SP_854x480_15fps_256kbps_AACLC_16khz_48kbps_s_0_26.mp4";
+        final int outWidth = 128;
+        final int outHeight = 128;
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        MediaVideoItem mediaVideoItem = null;
+        mediaVideoItem =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
+                videoItemFilename, renderingMode);
+        final long atTime = mediaVideoItem.getDuration() - 1000;
+        final Bitmap thumbNailBmp = mediaVideoItem.getThumbnail(outWidth,
+            outHeight, atTime);
+        validateThumbnail(thumbNailBmp, outWidth, outHeight);
+    }
+
+    /**
+     * To test thumbnail / frame extraction on H264 960x720.
+     */
+    // TODO : TC_TN_010
+    @LargeTest
+    public void testThumbnailForH264HD960() throws Exception {
+        final String videoItemFilename = INPUT_FILE_PATH +
+            "H264_MP_960x720_25fps_800kbps_AACLC_48Khz_192Kbps_s_1_17.mp4";
+        final int outWidth = 75;
+        final int outHeight = 75;
+
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        final MediaVideoItem mediaVideoItem =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
+                videoItemFilename, renderingMode);
+        final long atTime = mediaVideoItem.getDuration() - 1000;
+        final Bitmap thumbNailBmp = mediaVideoItem.getThumbnail(outWidth,
+            outHeight, atTime);
+        validateThumbnail(thumbNailBmp, outWidth, outHeight);
+    }
+
+    /**
+     * To test thumbnail / frame extraction on H264 1080x720 .
+     */
+    // TODO : TC_TN_011
+    @LargeTest
+    public void testThumbnailForH264HD1080() throws Exception {
+        final String videoItemFilename = INPUT_FILE_PATH +
+            "H264_BP_1080x720_30fps_800kbps_1_17.mp4";
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        final MediaVideoItem mediaVideoItem =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
+                videoItemFilename, renderingMode);
+        final int outWidth = mediaVideoItem.getWidth() / 2;
+        final int outHeight = mediaVideoItem.getHeight() / 2;
+        final long atTime = mediaVideoItem.getDuration() / 4;
+        final Bitmap thumbNailBmp = mediaVideoItem.getThumbnail(outWidth,
+            outHeight, atTime);
+        validateThumbnail(thumbNailBmp, outWidth, outHeight);
+    }
+
+    /**
+     * Check the thumbnail / frame extraction precision at 0,100 and 200 ms
+     */
+    // TODO : TC_TN_012
+    @LargeTest
+    public void testThumbnailForH264VGADifferentDuration() throws Exception {
+        final String videoItemFilename = INPUT_FILE_PATH +
+            "H264_BP_640x480_30fps_256kbps_1_17.mp4";
+        final int atTime = 0;
+        final int atTime1 = 100;
+        final int atTime2 = 200;
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+
+        final MediaVideoItem mediaVideoItem =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
+                videoItemFilename, renderingMode);
+        final int outWidth = mediaVideoItem.getWidth();
+        final int outHeight = mediaVideoItem.getHeight();
+
+        final Bitmap thumbNailBmp = mediaVideoItem.getThumbnail(outWidth,
+            outHeight, atTime);
+        validateThumbnail(thumbNailBmp, outWidth, outHeight);
+
+        // get Thumbnail @ 100ms
+        final Bitmap thumbNailBmpAt100 =
+            mediaVideoItem.getThumbnail(outWidth, outHeight, atTime1);
+        validateThumbnail(thumbNailBmpAt100, outWidth, outHeight);
+
+        // get Thumbnail @ 200ms
+        final Bitmap thumbNailBmpAt200 = mediaVideoItem.getThumbnail(
+            outWidth, outHeight, atTime2);
+        validateThumbnail(thumbNailBmpAt200, outWidth, outHeight);
+    }
+
+    /**
+     *Check the thumbnail / frame extraction precision at
+     * FileDuration,FileDuration/2 + 100 andFileDuration/2 + 200 ms
+     */
+    // TODO : TC_TN_013
+    @LargeTest
+    public void testThumbnailForMP4VGA() throws Exception {
+        final String videoItemFilename = INPUT_FILE_PATH +
+            "MPEG4_SP_640x480_15fps_256kbps_0_30.mp4";
+        final MediaVideoItem mediaVideoItem =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
+                videoItemFilename, MediaItem.RENDERING_MODE_BLACK_BORDER);
+
+        final int outWidth = mediaVideoItem.getWidth();
+        final int outHeight = mediaVideoItem.getHeight();
+        final long atTime = mediaVideoItem.getDuration() / 2;
+        final long atTime1 = atTime + 100;
+        final long atTime2 = atTime + 200;
+
+        // get Thumbnail @ duration/2
+        final Bitmap thumbNailBmp = mediaVideoItem.getThumbnail(outWidth,
+            outHeight, atTime);
+        validateThumbnail(thumbNailBmp, outWidth, outHeight);
+
+        // get Thumbnail @ duration/2 + 100ms
+        final Bitmap thumbNailBmpAt100 = mediaVideoItem.getThumbnail(
+            outWidth, outHeight, atTime1);
+        validateThumbnail(thumbNailBmpAt100, outWidth, outHeight);
+
+        // get Thumbnail @ duration/2 + 200ms
+        final Bitmap thumbNailBmpAt200 = mediaVideoItem.getThumbnail(
+            outWidth, outHeight, atTime2);
+        validateThumbnail(thumbNailBmpAt200, outWidth, outHeight);
+    }
+
+    /**
+     * Check the thumbnail / frame extraction on JPEG file
+     */
+    // TODO : TC_TN_014
+    @LargeTest
+    public void testThumbnailForImage() throws Exception {
+        final String imageItemFilename = INPUT_FILE_PATH + "IMG_640x480.jpg";
+        final int mediaDuration = 1000;
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        boolean flagForException = false;
+        int outWidth = 0;
+        int outHeight = 0;
+
+        final MediaImageItem mii = mVideoEditorHelper.createMediaItem(
+            mVideoEditor, "m1", imageItemFilename, mediaDuration, renderingMode);
+        assertNotNull("Media Image Item is Null",  mii);
+        outWidth =  mii.getWidth() / 2;
+        outHeight =  mii.getHeight() / 2;
+
+        final Bitmap thumbNailBmp = mii.getThumbnail(outWidth,
+            outHeight, mediaDuration);
+        validateThumbnail(thumbNailBmp, outWidth, outHeight);
+    }
+    /**
+     *To test ThumbnailList for H263 QCIF
+     */
+    // TODO : TC_TN_015
+    @LargeTest
+    public void testThumbnailListH263QCIF() throws Exception {
+        final String videoItemFilename = INPUT_FILE_PATH
+            + "H263_profile0_176x144_15fps_256kbps_AACLC_32kHz_128kbps_s_1_17.3gp";
+        final int startTime = 0;
+        final int tnCount = 10;
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        final MediaVideoItem mediaVideoItem =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
+                videoItemFilename, renderingMode);
+
+        final int outWidth = mediaVideoItem.getWidth() / 4;
+        final int outHeight = mediaVideoItem.getHeight() / 4;
+        final long endTime = mediaVideoItem.getDuration() / 2;
+
+        final Bitmap thumbNailBmp[] = mediaVideoItem.getThumbnailList(
+            outWidth, outHeight, startTime, endTime, tnCount);
+        assertNotNull("Thumbnail Retrived is Null", thumbNailBmp);
+        assertEquals("Thumbnail Count", tnCount, thumbNailBmp.length);
+
+        for (int i = 0; i < thumbNailBmp.length; i++) {
+            validateThumbnail(thumbNailBmp[i], outWidth, outHeight);
+            thumbNailBmp[i] = null;
+        }
+    }
+
+    /**
+     *To test ThumbnailList for MPEG4 QCIF
+     */
+    // TODO : TC_TN_016
+    @LargeTest
+    public void testThumbnailListMPEG4QCIF() throws Exception {
+        final String videoItemFilename = INPUT_FILE_PATH
+            + "MPEG4_SP_176x144_30fps_256kbps_AACLC_96kbps_44kHz_s_1_17.3gp";
+        final int tnCount = 10;
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+
+        final MediaVideoItem mediaVideoItem =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
+                videoItemFilename, renderingMode);
+
+        final int outWidth = mediaVideoItem.getWidth() / 2;
+        final int outHeight = mediaVideoItem.getHeight() / 2;
+        final long startTime = mediaVideoItem.getDuration() / 2;
+        final long endTime = mediaVideoItem.getDuration();
+
+        final Bitmap thumbNailBmp[] = mediaVideoItem.getThumbnailList(
+            outWidth, outHeight, startTime, endTime, tnCount);
+
+        assertNotNull("Thumbnail Retrived is Null", thumbNailBmp);
+        assertEquals("Thumbnail Count", tnCount, thumbNailBmp.length);
+        for (int i = 0; i < thumbNailBmp.length; i++) {
+            validateThumbnail(thumbNailBmp[i], outWidth, outHeight);
+            thumbNailBmp[i] = null;
+        }
+    }
+
+    /**
+     *To test ThumbnailList for H264 VGA
+     */
+    // TODO : TC_TN_017
+    @LargeTest
+    public void testThumbnailListH264VGA() throws Exception {
+        final String videoItemFilename = INPUT_FILE_PATH +
+            "H264_BP_640x480_30fps_256kbps_1_17.mp4";
+        final int tnCount = 10;
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        final MediaVideoItem mediaVideoItem =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
+                videoItemFilename, renderingMode);
+
+        final int outWidth = mediaVideoItem.getWidth() / 2;
+        final int outHeight = mediaVideoItem.getHeight() / 2;
+        final long startTime = mediaVideoItem.getDuration() / 3;
+        final long endTime = mediaVideoItem.getDuration() / 2;
+
+        final Bitmap thumbNailBmp[] = mediaVideoItem.getThumbnailList(
+            outWidth, outHeight, startTime, endTime, tnCount);
+        assertNotNull("Thumbnail Retrived is Null", thumbNailBmp);
+        assertEquals("Thumbnail Count", tnCount, thumbNailBmp.length);
+        for (int i = 0; i < thumbNailBmp.length; i++) {
+            validateThumbnail(thumbNailBmp[i], outWidth, outHeight);
+            thumbNailBmp[i] = null;
+        }
+    }
+
+    /**
+     *To test ThumbnailList for H264 WVGA
+     */
+    // TODO : TC_TN_018
+    @LargeTest
+    public void testThumbnailListH264WVGA() throws Exception {
+        final String videoItemFilename = INPUT_FILE_PATH +
+            "H264_BP_800x480_15fps_512kbps_AACLC_24KHz_38Kbps_s_1_17.mp4";
+        final int tnCount = 10;
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        final MediaVideoItem mediaVideoItem =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
+                videoItemFilename, renderingMode);
+
+        final int outWidth = mediaVideoItem.getWidth() / 2;
+        final int outHeight = mediaVideoItem.getHeight() / 2;
+        final long startTime = mediaVideoItem.getDuration() / 3;
+        final long endTime = mediaVideoItem.getDuration() / 2;
+
+        final Bitmap thumbNailBmp[] = mediaVideoItem.getThumbnailList(
+            outWidth, outHeight, startTime, endTime, tnCount);
+        assertNotNull("Thumbnail Retrived is Null", thumbNailBmp);
+        assertEquals("Thumbnail Count", tnCount, thumbNailBmp.length);
+        for (int i = 0; i < thumbNailBmp.length; i++) {
+            validateThumbnail(thumbNailBmp[i], outWidth, outHeight);
+            thumbNailBmp[i] = null;
+        }
+    }
+
+    /**
+     *To test ThumbnailList for H264 VGA ,Time exceeding file duration
+     */
+    // TODO : TC_TN_019
+    @LargeTest
+    public void testThumbnailH264VGAExceedingFileDuration() throws Exception {
+        final String videoItemFilename = INPUT_FILE_PATH +
+            "H264_BP_640x480_30fps_256kbps_1_17.mp4";
+        boolean flagForException = false;
+        int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+
+        try {
+            final MediaVideoItem mediaVideoItem =
+                mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
+                    videoItemFilename, renderingMode);
+            final int outWidth = mediaVideoItem.getWidth() / 2;
+            final int outHeight = mediaVideoItem.getHeight() / 2;
+            final long atTime = mediaVideoItem.getDuration() + 2000;
+            mediaVideoItem.getThumbnail(outWidth, outHeight, atTime);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Exception in Extracting thumbanil with Invalid Time",
+            flagForException);
+    }
+
+    /**
+     *To test ThumbnailList for VGA Image
+     */
+    // TODO : TC_TN_020
+    @LargeTest
+    public void testThumbnailListVGAImage() throws Exception {
+        final String imageItemFilename = INPUT_FILE_PATH + "IMG_640x480.jpg";
+        final int imageItemDuration = 10000;
+        final int startTime = 0;
+        final int endTime = 0;
+        final int tnCount = 10;
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+
+        final MediaImageItem mediaImageItem =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
+                imageItemFilename, imageItemDuration, renderingMode);
+        final int outWidth = mediaImageItem.getWidth() / 2;
+        final int outHeight = mediaImageItem.getHeight() / 2;
+
+        final Bitmap thumbNailBmp[] = mediaImageItem.getThumbnailList
+            (outWidth, outHeight, startTime, endTime, tnCount);
+        assertNotNull("Thumbnail Retrived is Null", thumbNailBmp);
+        assertEquals("Thumbnail Count", tnCount, thumbNailBmp.length);
+        for (int i = 0; i < thumbNailBmp.length; i++) {
+            validateThumbnail(thumbNailBmp[i], outWidth, outHeight);
+            thumbNailBmp[i] = null;
+        }
+    }
+
+    /**
+     *To test ThumbnailList for Invalid file path
+     */
+    // TODO : TC_TN_021
+    @LargeTest
+    public void testThumbnailForInvalidFilePath() throws Exception {
+        final String imageItemFileName = INPUT_FILE_PATH + "/sdcard/abc.jpg";
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        boolean flagForException = false;
+        try{
+        final MediaImageItem mii = new MediaImageItem(mVideoEditor, "m1",
+            imageItemFileName, 3000, renderingMode);
+        }catch (IllegalArgumentException e){
+            flagForException = true;
+        }
+        assertTrue(" Invalid File Path", flagForException);
+    }
+
+    /**
+     * To test thumbnail / frame extraction with setBoundaries
+     */
+    // TODO : TC_TN_022
+    @LargeTest
+    public void testThumbnailForMPEG4WVGAWithSetBoundaries() throws Exception {
+        final String videoItemFilename = INPUT_FILE_PATH +
+            "MPEG4_SP_800x480_515kbps_15fps_AMR_NB_8KHz_12.2kbps_m_0_26.mp4";
+        final int atTime = 10000;
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        final MediaVideoItem mediaVideoItem =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
+                videoItemFilename, renderingMode);
+
+        mediaVideoItem.setExtractBoundaries(1000,
+            (mediaVideoItem.getDuration() - 21000));
+
+        final int outWidth = (mediaVideoItem.getWidth() / 2);
+        final int outHeight = (mediaVideoItem.getHeight() / 2);
+        final Bitmap thumbNailBmp = mediaVideoItem.getThumbnail(outWidth,
+            outHeight, atTime);
+        validateThumbnail(thumbNailBmp, outWidth, outHeight);
+    }
+
+    /**
+     *To test ThumbnailList for H264 WVGA with setExtractboundaries
+     */
+    // TODO : TC_TN_023
+    @LargeTest
+    public void testThumbnailListForH264WVGAWithSetBoundaries() throws Exception {
+        final String videoItemFilename = INPUT_FILE_PATH +
+            "H264_BP_800x480_15fps_512kbps_1_17.mp4";
+        final int thumbNailStartTime = 10000;
+        final int thumbNailEndTime = 12000;
+        final int tnCount = 10;
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        final MediaVideoItem mediaVideoItem =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
+                videoItemFilename, renderingMode);
+
+        final int outWidth = (mediaVideoItem.getWidth() / 2);
+        final int outHeight = (mediaVideoItem.getHeight() / 2);
+
+        mediaVideoItem.setExtractBoundaries(10000, 12000);
+
+        final Bitmap thumbNailBmp[] = mediaVideoItem.getThumbnailList
+            (outWidth, outHeight, thumbNailStartTime, thumbNailEndTime,
+             tnCount);
+        assertNotNull("Thumbnail Retrived is Null", thumbNailBmp);
+        assertTrue("Thumbnail Size", (thumbNailBmp.length > 0) ? true : false);
+        for (int i = 0; i < thumbNailBmp.length; i++) {
+            validateThumbnail(thumbNailBmp[i], outWidth, outHeight);
+            thumbNailBmp[i] = null;
+        }
+    }
+
+    /**
+     *To test ThumbnailList for H264 WVGA with count > frame available
+     */
+    // TODO : TC_TN_024
+    @LargeTest
+    public void testThumbnailListForH264WVGAWithCount() throws Exception {
+        final String videoItemFilename = INPUT_FILE_PATH +
+            "H264_BP_800x480_15fps_512kbps_AACLC_24KHz_38Kbps_s_1_17.mp4";
+        final int tnCount = 100;
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        final MediaVideoItem mediaVideoItem =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
+                videoItemFilename, renderingMode);
+
+        final int outWidth = (mediaVideoItem.getWidth() / 2);
+        final int outHeight = (mediaVideoItem.getHeight() / 2);
+        final long thumbNailStartTime = mediaVideoItem.getDuration() / 2;
+        final long thumbNailEndTime = thumbNailStartTime + 4000;
+        Bitmap thumbNailBmp[] = null;
+        boolean flagForException = false;
+        try{
+            thumbNailBmp = mediaVideoItem.getThumbnailList(outWidth, outHeight,
+                thumbNailStartTime, thumbNailEndTime, tnCount);
+        }catch (Exception e){
+            assertTrue("Unable to get Thumbnail list", flagForException);
+        }
+        if (thumbNailBmp.length <= tnCount) {
+            flagForException = true;
+        }
+        assertTrue("Thumbnail count more than asked", flagForException);
+    }
+
+    /**
+     *To test ThumbnailList for H264 WVGA with startTime > End Time
+     */
+    // TODO : TC_TN_025
+    @LargeTest
+    public void testThumbnailListH264WVGAWithStartGreaterEnd() throws Exception {
+        final String videoItemFilename = INPUT_FILE_PATH +
+            "H264_BP_800x480_15fps_512kbps_AACLC_24KHz_38Kbps_s_1_17.mp4";
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        final int tnCount = 10;
+        boolean flagForException = false;
+        final MediaVideoItem mediaVideoItem =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
+                videoItemFilename, renderingMode);
+        final int outWidth = (mediaVideoItem.getWidth() / 2);
+        final int outHeight = (mediaVideoItem.getHeight() / 2);
+        final long thumbNailStartTime = mediaVideoItem.getDuration() / 2;
+        final long thumbNailEndTime = thumbNailStartTime - 1000;
+        try{
+            mediaVideoItem.getThumbnailList(outWidth, outHeight,
+                thumbNailStartTime, thumbNailEndTime, tnCount);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Thumbnail Extraction where start time > end time",
+            flagForException);
+    }
+
+    /**
+     *To test ThumbnailList TC_TN_026 for H264 WVGA with startTime = End Time
+     */
+    // TODO : TC_TN_026
+    @LargeTest
+    public void testThumbnailListH264WVGAWithStartEqualEnd() throws Exception {
+        final String videoItemFilename = INPUT_FILE_PATH +
+            "H264_BP_800x480_15fps_512kbps_AACLC_24KHz_38Kbps_s_1_17.mp4";
+        final int tnCount = 1;
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+
+        final MediaVideoItem mediaVideoItem =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
+                videoItemFilename, renderingMode);
+        final int outWidth = (mediaVideoItem.getWidth() / 2);
+        final int outHeight = (mediaVideoItem.getHeight() / 2);
+        final long thumbNailStartTime = mediaVideoItem.getDuration() / 2;
+        final long thumbNailEndTime = thumbNailStartTime;
+        final Bitmap thumbNailBmp[] = mediaVideoItem.getThumbnailList(outWidth,
+            outHeight, thumbNailStartTime, thumbNailEndTime, tnCount);
+        assertNotNull("Thumbnail Retrived is Null", thumbNailBmp);
+        assertEquals("Thumbnail Count", tnCount, thumbNailBmp.length);
+        for (int i = 0; i < thumbNailBmp.length; i++) {
+            validateThumbnail(thumbNailBmp[i], outWidth, outHeight);
+            thumbNailBmp[i] = null;
+        }
+    }
+
+    /**
+     *To test ThumbnailList TC_TN_027 for file where video duration is less
+     * than file duration.
+     */
+    // TODO : TC_TN_027
+    @LargeTest
+    public void testThumbnailForVideoDurationLessFileDuration() throws Exception {
+        final String videoItemFilename = INPUT_FILE_PATH
+            + "H264_BP_640x480_15fps_1200Kbps_AACLC_48KHz_64kps_m_0_27.3gp";
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+            final MediaVideoItem mediaVideoItem =
+                mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
+                    videoItemFilename, renderingMode);
+            final int outWidth = (mediaVideoItem.getWidth() / 2);
+            final int outHeight = (mediaVideoItem.getHeight() / 2);
+            final long atTime = mediaVideoItem.getDuration() - 2000;
+            final Bitmap thumbNailBmp = mediaVideoItem.getThumbnail (outWidth,
+                outHeight, atTime);
+        validateThumbnail(thumbNailBmp, outWidth, outHeight);
+
+    }
+
+    /**
+     *To test ThumbnailList TC_TN_028 for file which has video part corrupted
+     */
+    // TODO : TC_TN_028
+    @LargeTest
+    public void testThumbnailWithCorruptedVideoPart() throws Exception {
+        final String videoItemFilename = INPUT_FILE_PATH +
+            "corrupted_H264_BP_640x480_12.5fps_256kbps_AACLC_16khz_24kbps_s_0_26.mp4";
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        boolean flagForException = false;
+
+        try {
+            final MediaVideoItem mediaVideoItem =
+                 mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
+                    videoItemFilename, renderingMode);
+            final int outWidth = mediaVideoItem.getWidth();
+            final int outHeight = mediaVideoItem.getHeight() * 2;
+            final Bitmap thumbNailBmp = mediaVideoItem.getThumbnail
+                (outWidth, outHeight, mediaVideoItem.getDuration()/2);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Corrupted File cannot be read", flagForException);
+    }
+
+    /**
+     * Check the thumbnail / frame list extraction for Height as Negative Value
+     */
+    // TODO : TC_TN_029
+    @LargeTest
+    public void testThumbnailWithNegativeHeight() throws Exception {
+        final String videoItemFilename = INPUT_FILE_PATH
+            + "MPEG4_SP_176x144_30fps_256kbps_AACLC_96kbps_44kHz_s_1_17.3gp";
+        final int tnCount = 10;
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        boolean flagForException = false;
+        try {
+            final MediaVideoItem mediaVideoItem =
+                mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
+                    videoItemFilename, renderingMode);
+            final int outWidth = (mediaVideoItem.getWidth() / 2);
+            final int outHeight = -1;
+            final long thumbNailStartTime =
+                mediaVideoItem.getBoundaryBeginTime()/2;
+            final long thumbNailEndTime = mediaVideoItem.getBoundaryEndTime();
+            mediaVideoItem.getThumbnailList(outWidth, outHeight,
+                thumbNailStartTime, thumbNailEndTime, tnCount);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Thumbnail List with negative Height", flagForException);
+    }
+
+    /**
+     * Check the thumbnail for Height as Zero
+     */
+    // TODO : TC_TN_030
+    @LargeTest
+    public void testThumbnailWithHeightAsZero() throws Exception {
+        final String videoItemFilename = INPUT_FILE_PATH
+            + "MPEG4_SP_176x144_30fps_256kbps_AACLC_96kbps_44kHz_s_1_17.3gp";
+        final int atTime = 100;
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        boolean flagForException = false;
+        try {
+            final MediaVideoItem mediaVideoItem =
+                mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
+                    videoItemFilename, renderingMode);
+            final int outWidth = (mediaVideoItem.getWidth() / 2);
+            final int outHeight = -1;
+            mediaVideoItem.getThumbnail(outWidth, outHeight, atTime);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Thumbnail List with Zero Height", flagForException);
+    }
+
+    /**
+     * Check the thumbnail for Height = 10
+     */
+    // TODO : TC_TN_031
+    @LargeTest
+    public void testThumbnailWithHeight() throws Exception {
+        final String videoItemFilename = INPUT_FILE_PATH
+            + "MPEG4_SP_176x144_30fps_256kbps_AACLC_96kbps_44kHz_s_1_17.3gp";
+        final int atTime = 1000;
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+            final MediaVideoItem mediaVideoItem =
+                mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
+                    videoItemFilename, renderingMode);
+            final int outWidth = (mediaVideoItem.getWidth() / 2);
+            final int outHeight = 10;
+            final Bitmap thumbNailBmp = mediaVideoItem.getThumbnail (outWidth,
+                outHeight, atTime);
+        validateThumbnail(thumbNailBmp, outWidth, outHeight);
+    }
+
+    /**
+     * Check the thumbnail / frame list extraction for Width as Negative Value
+     */
+    // TODO : TC_TN_032
+    @LargeTest
+    public void testThumbnailWithNegativeWidth() throws Exception {
+        final String videoItemFilename = INPUT_FILE_PATH
+            + "MPEG4_SP_176x144_30fps_256kbps_AACLC_96kbps_44kHz_s_1_17.3gp";
+        final int tnCount = 10;
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        boolean flagForException = false;
+        try {
+            final MediaVideoItem mediaVideoItem =
+                mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
+                    videoItemFilename, renderingMode);
+            final int outWidth = -1;
+            final int outHeight = mediaVideoItem.getHeight();
+            final long thumbNailStartTime =
+                mediaVideoItem.getBoundaryBeginTime()/2;
+            final long thumbNailEndTime = mediaVideoItem.getBoundaryEndTime();
+            mediaVideoItem.getThumbnailList(outWidth, outHeight, thumbNailStartTime,
+                thumbNailEndTime, tnCount);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Thumbnail List with negative Height", flagForException);
+    }
+
+    /**
+     * Check the thumbnail / frame list extraction for Width zero
+     */
+    // TODO : TC_TN_033
+    @LargeTest
+    public void testThumbnailWithWidthAsZero() throws Exception {
+        final String videoItemFilename = INPUT_FILE_PATH
+            + "MPEG4_SP_176x144_30fps_256kbps_AACLC_96kbps_44kHz_s_1_17.3gp";
+        final int atTime = 1000;
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        boolean flagForException = false;
+        try {
+            final MediaVideoItem mediaVideoItem =
+                mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
+                    videoItemFilename, renderingMode);
+            final int outWidth = 0;
+            final int outHeight = mediaVideoItem.getHeight() / 2;
+            mediaVideoItem.getThumbnail(outWidth, outHeight, atTime);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Thumbnail List with Zero Width", flagForException);
+    }
+
+    /**
+     * Check the thumbnail for Width = 10
+     */
+    // TODO : TC_TN_034
+    @LargeTest
+    public void testThumbnailWithWidth() throws Exception {
+        final String videoItemFilename = INPUT_FILE_PATH
+            + "MPEG4_SP_176x144_30fps_256kbps_AACLC_96kbps_44kHz_s_1_17.3gp";
+        final int atTime = 1000;
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        final MediaVideoItem mediaVideoItem =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
+                videoItemFilename, renderingMode);
+        final int outWidth = 10;
+        final int outHeight = mediaVideoItem.getHeight();
+        final Bitmap thumbNailBmp = mediaVideoItem.getThumbnail (outWidth,
+            outHeight, atTime);
+        validateThumbnail(thumbNailBmp, outWidth, outHeight);
+    }
+
+    /**
+     * To test thumbnail / frame extraction on MPEG4 (time beyond file duration).
+     */
+    // TODO : TC_TN_035
+    @LargeTest
+    public void testThumbnailMPEG4withMorethanFileDuration() throws Exception {
+        final String videoItemFilename = INPUT_FILE_PATH
+            + "MPEG4_SP_176x144_30fps_256kbps_AACLC_96kbps_44kHz_s_1_17.3gp";
+        boolean flagForException = false;
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        final MediaVideoItem mediaVideoItem =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
+                videoItemFilename, renderingMode);
+        final int outWidth =  mediaVideoItem.getWidth()/2;
+        final int outHeight =  mediaVideoItem.getHeight()/2;
+        final long atTime = mediaVideoItem.getDuration() + 100;
+        try{
+            final Bitmap thumbNailBmp = mediaVideoItem.getThumbnail (outWidth,
+            outHeight, atTime);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Thumbnail duration is more than file duration",
+            flagForException);
+    }
+}
diff --git a/media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/functional/MediaPropertiesTest.java b/media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/functional/MediaPropertiesTest.java
new file mode 100755
index 0000000..68130cc
--- /dev/null
+++ b/media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/functional/MediaPropertiesTest.java
@@ -0,0 +1,753 @@
+/*
+ * Copyright (C) 2011 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.
+ */
+
+package com.android.mediaframeworktest.functional;
+
+import java.io.File;
+import java.io.IOException;
+
+import android.media.videoeditor.AudioTrack;
+import android.media.videoeditor.MediaImageItem;
+import android.media.videoeditor.MediaItem;
+import android.media.videoeditor.MediaProperties;
+import android.media.videoeditor.MediaVideoItem;
+import android.media.videoeditor.VideoEditor;
+import android.os.Environment;
+import android.test.ActivityInstrumentationTestCase;
+import android.test.suitebuilder.annotation.LargeTest;
+import com.android.mediaframeworktest.MediaFrameworkTest;
+import com.android.mediaframeworktest.VideoEditorHelper;
+
+public class MediaPropertiesTest extends
+    ActivityInstrumentationTestCase<MediaFrameworkTest> {
+    private final String TAG = "MediaPropertiesTest";
+
+    private final String PROJECT_LOCATION = VideoEditorHelper.PROJECT_LOCATION_COMMON;
+
+    private final String INPUT_FILE_PATH = VideoEditorHelper.INPUT_FILE_PATH_COMMON;
+
+    private VideoEditor mVideoEditor;
+
+    private VideoEditorHelper mVideoEditorHelper;
+
+    public MediaPropertiesTest() {
+        super("com.android.mediaframeworktest", MediaFrameworkTest.class);
+    }
+
+    @Override
+    protected void setUp() throws Exception {
+        // setup for each test case.
+        super.setUp();
+        mVideoEditorHelper = new VideoEditorHelper();
+        // Create a random String which will be used as project path,
+        // where all project related files will be stored.
+        final String projectPath = mVideoEditorHelper.
+            createRandomFile(PROJECT_LOCATION);
+        mVideoEditor = mVideoEditorHelper.createVideoEditor(projectPath);
+    }
+
+    @Override
+    protected void tearDown() throws Exception {
+        mVideoEditorHelper.destroyVideoEditor(mVideoEditor);
+        // Clean the directory created as project path
+        mVideoEditorHelper.deleteProject(new File(mVideoEditor.getPath()));
+        System.gc();
+        super.tearDown();
+    }
+
+    protected void validateVideoProperties(int aspectRatio, int fileType,
+        int videoCodecType, int duration, int videoBitrate, int fps,
+        int videoProfile, int width, int height, int audioCodecType,
+        int audioSamplingFrequency, int audioChannel, int audioBitrate,
+        MediaVideoItem mvi) throws Exception {
+        assertEquals("Aspect Ratio Mismatch", aspectRatio, mvi.getAspectRatio());
+        assertEquals("File Type Mismatch", fileType, mvi.getFileType());
+        assertEquals("VideoCodec Mismatch", videoCodecType, mvi.getVideoType());
+
+        assertTrue("Video duration Mismatch", mVideoEditorHelper.checkRange (
+            duration, mvi.getDuration(), 10));
+        assertEquals("Video Profile " + mvi.getVideoProfile(), videoProfile,
+            mvi.getVideoProfile());
+        assertEquals("Video height " + mvi.getHeight(), height, mvi.getHeight());
+        assertEquals("Video width " + mvi.getWidth(), width, mvi.getWidth());
+        /** Check FPS with 10% range */
+        assertTrue("fps Mismatch" + mvi.getFps(),
+            mVideoEditorHelper.checkRange(fps, mvi.getFps(), 10));
+
+        assertEquals("AudioType Mismatch ", audioCodecType, mvi.getAudioType());
+        assertEquals("Audio Sampling " + mvi.getAudioSamplingFrequency(),
+            audioSamplingFrequency, mvi.getAudioSamplingFrequency());
+        assertEquals("Audio Channels " + mvi.getAudioChannels(), audioChannel,
+            mvi.getAudioChannels());
+
+        /**
+        if (videoBitrate != 0) {
+            assertTrue("VideoBitrate Mismatch <expected> " + videoBitrate +
+                "\t<actual> " + mvi.getVideoBitrate(),
+                mVideoEditorHelper.checkRange(videoBitrate, mvi.getVideoBitrate(), 10));
+        }
+        if (audioBitrate != 0) {
+            assertTrue("AudioBitrate Mismatch <expected> " + audioBitrate +
+                "\t<actual> " + mvi.getAudioBitrate(),
+                mVideoEditorHelper.checkRange(audioBitrate, mvi.getAudioBitrate(), 10));
+        }
+        */
+
+    }
+
+    protected void validateAudioProperties(int audioCodecType, int duration,
+        int audioSamplingFrequency, int audioChannel, int audioBitrate,
+        AudioTrack aT) throws Exception {
+        assertEquals("AudioType Mismatch ", audioCodecType, aT.getAudioType());
+        assertTrue("Video duration Mismatch", mVideoEditorHelper.checkRange (
+            duration, aT.getDuration(), 10));
+        assertEquals("Audio Sampling " + aT.getAudioSamplingFrequency(),
+            audioSamplingFrequency, aT.getAudioSamplingFrequency());
+        assertEquals("Audio Channels " + aT.getAudioChannels(), audioChannel,
+            aT.getAudioChannels());
+        /**
+        if (audioBitrate != 0) {
+            assertTrue("AudioBitrate Mismatch <expected> " + audioBitrate +
+                "\t<actual> " + aT.getAudioBitrate(),
+                mVideoEditorHelper.checkRange(audioBitrate, aT.getAudioBitrate(), 10));
+        }
+        */
+    }
+
+    protected void validateImageProperties(int aspectRatio, int fileType,
+        int width, int height, MediaImageItem mii)
+        throws Exception {
+        assertEquals("Aspect Ratio Mismatch", aspectRatio, mii.getAspectRatio());
+        assertEquals("File Type Mismatch", fileType, mii.getFileType());
+        assertEquals("Image height " + mii.getHeight(), height, mii.getHeight());
+        assertEquals("Image width " + mii.getWidth(), width, mii.getWidth());
+    }
+
+
+    /**
+     *To test Media Properties for file MPEG4 854 x 480
+     */
+    // TODO : Remove TC_MP_001
+    @LargeTest
+    public void testPropertiesMPEG4854_480() throws Exception {
+        final String videoItemFilename = INPUT_FILE_PATH
+            + "MPEG4_SP_854x480_15fps_256kbps_AACLC_16khz_48kbps_s_0_26.mp4";
+        final int aspectRatio = MediaProperties.ASPECT_RATIO_16_9;
+        final int fileType = MediaProperties.FILE_MP4;
+        final int videoCodecType = MediaProperties.VCODEC_MPEG4;
+        final int duration = 26933;
+        final int videoBitrate = 319000;
+        final int audioBitrate = 48000;
+        final int fps = 15;
+        final int audioCodecType = MediaProperties.ACODEC_AAC_LC;
+        final int audioSamplingFrequency = 16000;
+        final int audioChannel = 2;
+        final int videoProfile = 0;
+        final int width = 854;
+        final int height = MediaProperties.HEIGHT_480;
+
+        final MediaVideoItem mvi = mVideoEditorHelper.createMediaItem
+            (mVideoEditor, "m1", videoItemFilename,
+            MediaItem.RENDERING_MODE_BLACK_BORDER);
+
+        validateVideoProperties(aspectRatio, fileType, videoCodecType, duration,
+            videoBitrate, fps, videoProfile, width, height, audioCodecType,
+            audioSamplingFrequency, audioChannel, audioBitrate, mvi);
+    }
+
+
+    /**
+     *To test Media Properties for file MPEG4 WVGA
+     */
+    // TODO : Remove TC_MP_002
+    @LargeTest
+    public void testPropertiesMPEGWVGA() throws Exception {
+        final String videoItemFilename = INPUT_FILE_PATH
+            + "MPEG4_SP_800x480_515kbps_15fps_AMR_NB_8KHz_12.2kbps_m_0_26.mp4";
+        final int aspectRatio = MediaProperties.ASPECT_RATIO_5_3;
+        final int fileType = MediaProperties.FILE_3GP;
+        final int videoCodecType = MediaProperties.VCODEC_MPEG4;
+        final int duration = 26933;
+        final int videoBitrate = 384000;
+        final int audioBitrate = 12800;
+        final int fps = 15;
+        final int audioCodecType = MediaProperties.ACODEC_AMRNB;
+        final int audioSamplingFrequency = 8000;
+        final int audioChannel = 1;
+        final int videoProfile = 0;
+        final int width = 800;
+        final int height = MediaProperties.HEIGHT_480;
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+
+        final MediaVideoItem mvi = mVideoEditorHelper.createMediaItem
+            (mVideoEditor, "m1", videoItemFilename, renderingMode);
+
+        validateVideoProperties(aspectRatio, fileType, videoCodecType, duration,
+            videoBitrate, fps, videoProfile, width, height, audioCodecType,
+            audioSamplingFrequency, audioChannel, audioBitrate, mvi);
+    }
+
+    /**
+     *To test media properties for MPEG4 720x480 (NTSC) + AAC file.
+     */
+    // TODO : Remove TC_MP_003
+    @LargeTest
+    public void testPropertiesMPEGNTSC() throws Exception {
+        final String videoItemFilename = INPUT_FILE_PATH
+            + "MPEG4_SP_720x480_30fps_280kbps_AACLC_48kHz_161kbps_s_0_26.mp4";
+        final int aspectRatio = MediaProperties.ASPECT_RATIO_3_2;
+        final int fileType = MediaProperties.FILE_MP4;
+        final int videoCodecType = MediaProperties.VCODEC_MPEG4;
+        final int duration = 26866;
+        final int videoBitrate = 403000;
+        final int audioBitrate = 160000;
+        final int fps = 30;
+        final int audioCodecType = MediaProperties.ACODEC_AAC_LC;
+        final int audioSamplingFrequency = 48000;
+        final int audioChannel = 2;
+        final int videoProfile = 0;
+        final int width = 720;
+        final int height = MediaProperties.HEIGHT_480;
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+
+        final MediaVideoItem mvi = mVideoEditorHelper.createMediaItem
+            (mVideoEditor, "m1", videoItemFilename, renderingMode);
+
+        validateVideoProperties(aspectRatio, fileType, videoCodecType, duration,
+            videoBitrate, fps, videoProfile, width, height, audioCodecType,
+            audioSamplingFrequency, audioChannel, audioBitrate, mvi);
+    }
+
+    /**
+     *To test Media Properties for file MPEG4 VGA
+     */
+    // TODO : Remove TC_MP_004
+    @LargeTest
+    public void testPropertiesMPEGVGA() throws Exception {
+        final String videoItemFilename = INPUT_FILE_PATH
+            + "MPEG4_SP_640x480_15fps_512kbps_AACLC_48khz_132kbps_s_0_26.mp4";
+        final int aspectRatio = MediaProperties.ASPECT_RATIO_4_3;
+        final int fileType = MediaProperties.FILE_MP4;
+        final int videoCodecType = MediaProperties.VCODEC_MPEG4;
+        final int duration = 26933;
+        final int videoBitrate = 533000;
+        final int audioBitrate = 128000;
+        final int fps = 15;
+        final int audioCodecType = MediaProperties.ACODEC_AAC_LC;
+        final int audioSamplingFrequency = 48000;
+        final int audioChannel = 2;
+        final int videoProfile = 0;
+        final int width = 640;
+        final int height = MediaProperties.HEIGHT_480;
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+
+        final MediaVideoItem mvi = mVideoEditorHelper.createMediaItem
+            (mVideoEditor, "m1", videoItemFilename, renderingMode);
+
+        validateVideoProperties(aspectRatio, fileType, videoCodecType, duration,
+            videoBitrate, fps, videoProfile, width, height, audioCodecType,
+            audioSamplingFrequency, audioChannel, audioBitrate, mvi);
+    }
+
+    /**
+     *To test Media Properties for file MPEG4 QCIF
+     */
+    // TODO : Remove TC_MP_005
+    @LargeTest
+    public void testPropertiesMPEGQCIF() throws Exception {
+        final String videoItemFilename = INPUT_FILE_PATH
+            + "MPEG4_SP_176x144_12fps_92kbps_AMRNB_8KHz_12.2kbps_m_0_27.3gp";
+        final int aspectRatio = MediaProperties.ASPECT_RATIO_11_9;
+        final int fileType = MediaProperties.FILE_3GP;
+        final int videoCodecType = MediaProperties.VCODEC_MPEG4;
+        final int duration = 27000;
+        final int videoBitrate = 384000;
+        final int audioBitrate = 12200;
+        final int fps = 12;
+        final int audioCodecType = MediaProperties.ACODEC_AMRNB;
+        final int audioSamplingFrequency = 8000;
+        final int audioChannel = 1;
+        final int videoProfile = 0;
+        final int width = 176;
+        final int height = MediaProperties.HEIGHT_144;
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+
+        final MediaVideoItem mvi = mVideoEditorHelper.createMediaItem
+            (mVideoEditor, "m1", videoItemFilename, renderingMode);
+
+        validateVideoProperties(aspectRatio, fileType, videoCodecType, duration,
+            videoBitrate, fps, videoProfile, width, height, audioCodecType,
+            audioSamplingFrequency, audioChannel, audioBitrate, mvi);
+    }
+
+    /**
+     *To To test media properties for H263 176x144 (QCIF) + AAC (mono) file.
+     */
+    // TODO : Remove TC_MP_006
+    @LargeTest
+    public void testPropertiesH263QCIF() throws Exception {
+        final String videoItemFilename = INPUT_FILE_PATH
+            + "H263_profile0_176x144_15fps_256kbps_AACLC_16kHz_32kbps_m_0_26.3gp";
+        final int aspectRatio = MediaProperties.ASPECT_RATIO_11_9;
+        final int fileType = MediaProperties.FILE_3GP;
+        final int videoCodecType = MediaProperties.VCODEC_H263;
+        final int duration = 26933;
+        final int videoBitrate = 384000;
+        final int audioBitrate = 64000;
+        final int fps = 15;
+        final int audioCodecType = MediaProperties.ACODEC_AAC_LC;
+        final int audioSamplingFrequency = 16000;
+        final int audioChannel = 1;
+        final int videoProfile = 0;
+        final int width = 176;
+        final int height = MediaProperties.HEIGHT_144;
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        final MediaVideoItem mvi = mVideoEditorHelper.createMediaItem
+            (mVideoEditor, "m1", videoItemFilename, renderingMode);
+
+        validateVideoProperties(aspectRatio, fileType, videoCodecType, duration,
+            videoBitrate, fps, videoProfile, width, height, audioCodecType,
+            audioSamplingFrequency, audioChannel, audioBitrate, mvi);
+    }
+
+    /**
+     *To test Media Properties for file H264 VGA
+     */
+    // TODO : Remove TC_MP_007
+    @LargeTest
+    public void testPropertiesH264VGA() throws Exception {
+        final String videoItemFilename = INPUT_FILE_PATH
+            + "H264_BP_640x480_15fps_1200Kbps_AACLC_48KHz_64kps_m_0_27.3gp";
+        final int aspectRatio = MediaProperties.ASPECT_RATIO_4_3;
+        final int fileType = MediaProperties.FILE_3GP;
+        final int videoCodecType = MediaProperties.VCODEC_H264BP;
+        final int duration = 77600;
+        final int videoBitrate = 745000;
+        final int audioBitrate = 64000;
+        final int fps = 15;
+        final int audioCodecType = MediaProperties.ACODEC_AAC_LC;
+        final int audioSamplingFrequency = 48000;
+        final int audioChannel = 2;
+        final int videoProfile = 0;
+        final int width = 640;
+        final int height = MediaProperties.HEIGHT_480;
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        final MediaVideoItem mvi = mVideoEditorHelper.createMediaItem
+            (mVideoEditor, "m1", videoItemFilename, renderingMode);
+
+        validateVideoProperties(aspectRatio, fileType, videoCodecType, duration,
+            videoBitrate, fps, videoProfile, width, height, audioCodecType,
+            audioSamplingFrequency, audioChannel, audioBitrate, mvi);
+    }
+
+    /**
+     *To test Media Properties for file H264 NTSC
+     */
+    // TODO : Remove TC_MP_008
+    @LargeTest
+    public void testPropertiesH264NTSC() throws Exception {
+        final String videoItemFilename = INPUT_FILE_PATH
+            + "H264_BP_720x480_25fps_256kbps_AMRNB_8khz_12.2kbps_m_0_26.mp4";
+        final int aspectRatio = MediaProperties.ASPECT_RATIO_3_2;
+        final int fileType = MediaProperties.FILE_MP4;
+        final int videoCodecType = MediaProperties.VCODEC_H264BP;
+        final int duration = 26880;
+        final int videoBitrate = 244000;
+        final int audioBitrate = 12200;
+        final int fps = 25;
+        final int audioCodecType = MediaProperties.ACODEC_AMRNB;
+        final int audioSamplingFrequency = 8000;
+        final int audioChannel = 1;
+        final int videoProfile = 0;
+        final int width = 720;
+        final int height = MediaProperties.HEIGHT_480;
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+
+        final MediaVideoItem mvi = mVideoEditorHelper.createMediaItem
+            (mVideoEditor, "m1", videoItemFilename, renderingMode);
+
+        validateVideoProperties(aspectRatio, fileType, videoCodecType, duration,
+            videoBitrate, fps, videoProfile, width, height, audioCodecType,
+            audioSamplingFrequency, audioChannel, audioBitrate, mvi);
+    }
+
+    /**
+     *To test media properties for H264 800x480 (WVGA) + AAC file.
+     */
+    // TODO : Remove TC_MP_009
+    @LargeTest
+    public void testPropertiesH264WVGA() throws Exception {
+        final String videoItemFilename = INPUT_FILE_PATH +
+              "H264_BP_800x480_15fps_512kbps_AACLC_24KHz_38Kbps_s_1_17.mp4";
+        final int aspectRatio = MediaProperties.ASPECT_RATIO_5_3;
+        final int fileType = MediaProperties.FILE_MP4;
+        final int videoCodecType = MediaProperties.VCODEC_H264BP;
+        final int duration = 77466;
+        final int videoBitrate = 528000;
+        final int audioBitrate = 38000;
+        final int fps = 15;
+        final int audioCodecType = MediaProperties.ACODEC_AAC_LC;
+        final int audioSamplingFrequency = 24000;
+        final int audioChannel = 2;
+        final int videoProfile = 0;
+        final int width = 800;
+        final int height = MediaProperties.HEIGHT_480;
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+
+        final MediaVideoItem mvi = mVideoEditorHelper.createMediaItem
+            (mVideoEditor, "m1", videoItemFilename, renderingMode);
+
+        validateVideoProperties(aspectRatio, fileType, videoCodecType, duration,
+            videoBitrate, fps, videoProfile, width, height, audioCodecType,
+            audioSamplingFrequency, audioChannel, audioBitrate, mvi);
+    }
+
+    /**
+     *To test Media Properties for file H264 HD1280
+     */
+    // TODO : Remove TC_MP_010
+    @LargeTest
+    public void testPropertiesH264HD1280() throws Exception {
+        final String videoItemFilename = INPUT_FILE_PATH
+            + "H264_BP_1280x720_15fps_512kbps_AACLC_16khz_48kbps_s_1_17.mp4";
+        final int aspectRatio = MediaProperties.ASPECT_RATIO_16_9;
+        final int fileType = MediaProperties.FILE_MP4;
+        final int videoCodecType = MediaProperties.VCODEC_H264BP;
+        final int duration = 77600;
+        final int videoBitrate = 606000;
+        final int audioBitrate = 48000;
+        final int fps = 15;
+        final int audioCodecType = MediaProperties.ACODEC_AAC_LC;
+        final int audioSamplingFrequency = 16000;
+        final int audioChannel = 2;
+        final int videoProfile = 0;
+        final int width = 1280;
+        final int height = MediaProperties.HEIGHT_720;
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+
+        final MediaVideoItem mvi = mVideoEditorHelper.createMediaItem
+            (mVideoEditor, "m1", videoItemFilename, renderingMode);
+
+        validateVideoProperties(aspectRatio, fileType, videoCodecType, duration,
+            videoBitrate, fps, videoProfile, width, height, audioCodecType,
+            audioSamplingFrequency, audioChannel, audioBitrate, mvi);
+    }
+
+    /**
+     *To test media properties for H264 1080x720 + AAC file
+     */
+    // TODO : Remove TC_MP_011
+    @LargeTest
+    public void testPropertiesH264HD1080WithAudio() throws Exception {
+        final String videoItemFilename = INPUT_FILE_PATH
+            + "H264_BP_1080x720_30fps_12Mbps_AACLC_44.1khz_64kbps_s_1_17.mp4";
+        final int aspectRatio = MediaProperties.ASPECT_RATIO_3_2;
+        final int fileType = MediaProperties.FILE_MP4;
+        final int videoCodecType = MediaProperties.VCODEC_H264BP;
+        final int duration = 77500;
+        final int videoBitrate = 1190000;
+        final int audioBitrate = 64000;
+        final int fps = 10;
+        final int audioCodecType = MediaProperties.ACODEC_AAC_LC;
+        final int audioSamplingFrequency = 44100;
+        final int audioChannel = 2;
+        final int videoProfile = 0;
+        final int width = 1080;
+        final int height = MediaProperties.HEIGHT_720;
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+
+        final MediaVideoItem mvi = mVideoEditorHelper.createMediaItem
+            (mVideoEditor, "m1", videoItemFilename, renderingMode);
+
+        validateVideoProperties(aspectRatio, fileType, videoCodecType, duration,
+            videoBitrate, fps, videoProfile, width, height, audioCodecType,
+            audioSamplingFrequency, audioChannel, audioBitrate, mvi);
+    }
+
+    /**
+     *To test Media Properties for file WMV - Unsupported type
+     */
+    // TODO : Remove TC_MP_012
+    @LargeTest
+    public void testPropertiesWMVFile() throws Exception {
+        final String videoItemFilename = INPUT_FILE_PATH +
+            "WMV_V7_640x480_15fps_512Kbps_wma_V9_44khz_48Kbps_s_1_30.wmv";
+        boolean flagForException = false;
+        try {
+            new MediaVideoItem(mVideoEditor, "m1", videoItemFilename,
+                MediaItem.RENDERING_MODE_BLACK_BORDER);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Media Properties for a WMV File -- Unsupported file type",
+            flagForException);
+    }
+
+    /**
+     *To test media properties for H.264 Main/Advanced profile. (unsupported profile input)
+     */
+    // TODO : Remove TC_MP_013
+    @LargeTest
+    public void testPropertiesH264MainLineProfile() throws Exception {
+        final String videoItemFilename = INPUT_FILE_PATH
+            + "H264_MP_960x720_25fps_800kbps_AACLC_48Khz_192Kbps_s_1_17.mp4";
+        final int aspectRatio = MediaProperties.ASPECT_RATIO_4_3;
+        //final int videoCodecType = MediaProperties.VCODEC_H264BP;
+        final int videoCodecType = MediaProperties.VCODEC_H264MP;
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        boolean flagForException = false;
+
+        try {
+        final MediaVideoItem mvi = mVideoEditorHelper.createMediaItem
+            (mVideoEditor, "m1", videoItemFilename, renderingMode);
+            assertEquals("VideoCodec Mismatch", videoCodecType, mvi.getVideoType());
+        }catch (IllegalArgumentException e){
+            flagForException = true;
+        }
+            assertTrue("Unsupported Main Profile", flagForException);
+    }
+
+    /**
+     *To test Media Properties for non existing file.
+     */
+    // TODO : Remove TC_MP_014
+    @LargeTest
+    public void testPropertiesForNonExsitingFile() throws Exception {
+        final String videoItemFilename = INPUT_FILE_PATH + "abc.3gp";
+        boolean flagForException = false;
+
+        try {
+            new MediaVideoItem(mVideoEditor, "m1", videoItemFilename,
+                MediaItem.RENDERING_MODE_BLACK_BORDER);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Media Properties for non exsisting file", flagForException);
+     }
+
+    /**
+     *To test Media Properties for file H264 HD1080
+     */
+    // TODO : Remove TC_MP_015
+    @LargeTest
+    public void testPropertiesH264HD1080WithoutAudio() throws Exception {
+        final String videoItemFilename = INPUT_FILE_PATH +
+            "H264_BP_1080x720_30fps_800kbps_1_17.mp4";
+        final int aspectRatio = MediaProperties.ASPECT_RATIO_3_2;
+        final int fileType = MediaProperties.FILE_MP4;
+        final int videoCodecType = MediaProperties.VCODEC_H264BP;
+        final int duration = 77366;
+        final int videoBitrate = 859000;
+        final int audioBitrate = 0;
+        final int fps = 30;
+        final int audioCodecType = -1;
+        final int audioSamplingFrequency = 0;
+        final int audioChannel = 0;
+        final int videoProfile = 0;
+        final int width = 1080;
+        final int height = MediaProperties.HEIGHT_720;
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+
+        final MediaVideoItem mvi = mVideoEditorHelper.createMediaItem
+            (mVideoEditor, "m1", videoItemFilename, renderingMode);
+
+        validateVideoProperties(aspectRatio, fileType, videoCodecType, duration,
+            videoBitrate, fps, videoProfile, width, height, audioCodecType,
+            audioSamplingFrequency, audioChannel, audioBitrate, mvi);
+    }
+
+    /**
+     *To test Media Properties for Image file of JPEG Type
+     */
+    // TODO : Remove TC_MP_016
+    @LargeTest
+    public void testPropertiesVGAImage() throws Exception {
+        final String imageItemFilename = INPUT_FILE_PATH + "IMG_640x480.jpg";
+        final int imageItemDuration = 10000;
+        final int aspectRatio = MediaProperties.ASPECT_RATIO_4_3;
+        final int fileType = MediaProperties.FILE_JPEG;
+        final int width = 640;
+        final int height = MediaProperties.HEIGHT_480;
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+
+        final MediaImageItem mii = mVideoEditorHelper.createMediaItem
+            (mVideoEditor, "m1", imageItemFilename, imageItemDuration,
+            renderingMode);
+        validateImageProperties(aspectRatio, fileType, width, height, mii);
+    }
+
+    /**
+     *To test Media Properties for Image file of PNG Type
+     */
+    // TODO : Remove TC_MP_017
+    @LargeTest
+    public void testPropertiesPNG() throws Exception {
+        final String imageItemFilename = INPUT_FILE_PATH + "IMG_640x480.png";
+        final int imageItemDuration = 10000;
+        final int aspectRatio = MediaProperties.ASPECT_RATIO_4_3;
+        final int fileType = MediaProperties.FILE_PNG;
+        final int width = 640;
+        final int height = 480;
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        final MediaImageItem mii = mVideoEditorHelper.createMediaItem
+            (mVideoEditor, "m1", imageItemFilename, imageItemDuration,
+            renderingMode);
+        validateImageProperties(aspectRatio, fileType, width, height, mii);
+    }
+
+    /**
+     *To test Media Properties for file GIF - Unsupported type
+     */
+    // TODO : Remove TC_MP_018
+    @LargeTest
+    public void testPropertiesGIFFile() throws Exception {
+
+        final String imageItemFilename = INPUT_FILE_PATH + "IMG_640x480.gif";
+        final int imageItemDuration = 10000;
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        boolean flagForException = false;
+        try {
+            new MediaImageItem(mVideoEditor, "m1", imageItemFilename,
+                imageItemDuration, renderingMode);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Media Properties for a GIF File -- Unsupported file type",
+            flagForException);
+    }
+
+    /**
+     *To test Media Properties for file Text file named as 3GP
+     */
+    // TODO : Remove TC_MP_019
+    @LargeTest
+    public void testPropertiesofDirtyFile() throws Exception {
+
+        final String videoItemFilename = INPUT_FILE_PATH +
+            "Text_FileRenamedTo3gp.3gp";
+        boolean flagForException = false;
+
+        try {
+            new MediaVideoItem(mVideoEditor, "m1", videoItemFilename,
+                MediaItem.RENDERING_MODE_BLACK_BORDER);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+    }
+
+    /**
+     *To test Media Properties for file name as NULL
+     */
+    // TODO : Remove TC_MP_020
+    @LargeTest
+    public void testPropertieNULLFile() throws Exception {
+        final String videoItemFilename = null;
+        boolean flagForException = false;
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        try {
+            new MediaVideoItem(mVideoEditor, "m1", videoItemFilename,
+                renderingMode);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Media Properties for NULL  File ",
+            flagForException);
+    }
+
+    /**
+     *To test Media Properties for file which is of type MPEG2
+     */
+    // TODO : Remove TC_MP_021
+    @LargeTest
+    public void testPropertiesMPEG2File() throws Exception {
+        final String videoItemFilename = INPUT_FILE_PATH +
+            "MPEG2_640x480_30fps_192kbps_1_5.mp4";
+        boolean flagForException = false;
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        try {
+            new MediaVideoItem(mVideoEditor, "m1", videoItemFilename,
+                renderingMode);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Media Properties for a MPEG2 File --Unsupported file type",
+            flagForException);
+    }
+
+    /**
+     *To test Media Properties TC_MP_023 for file without Video only Audio
+     */
+    // TODO : Remove TC_MP_023
+    @LargeTest
+    public void testProperties3GPWithoutVideoMediaItem() throws Exception {
+        final String audioFilename = INPUT_FILE_PATH +
+            "AACLC_48KHz_256Kbps_s_1_17.3gp";
+        boolean flagForException = false;
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        try {
+            new MediaVideoItem(mVideoEditor, "m1", audioFilename,
+                renderingMode);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Exception in Creaing Media Video item object without video",
+            flagForException);
+    }
+
+    /**
+     *To test media properties for Audio Track file. (No Video, AAC Audio)
+     */
+    // TODO : Remove TC_MP_024
+    @LargeTest
+    public void testProperties3GPWithoutVideoAudioTrack() throws Exception {
+
+        final String audioFilename = INPUT_FILE_PATH +
+            "AACLC_44.1kHz_256kbps_s_1_17.mp4";
+        final int duration = 77554;
+        final int audioBitrate = 384000;
+        final int audioCodecType = MediaProperties.ACODEC_AAC_LC;
+        final int audioSamplingFrequency = 44100;
+        final int audioChannel = 2;
+
+        final AudioTrack audioTrack = mVideoEditorHelper.createAudio
+            (mVideoEditor, "a1", audioFilename);
+
+        validateAudioProperties(audioCodecType, duration, audioSamplingFrequency,
+            audioChannel, audioBitrate, audioTrack);
+    }
+
+        /**
+     *To test media properties for Audio Track file. MP3 file
+     */
+    // TODO : Remove TC_MP_025
+    @LargeTest
+    public void testPropertiesMP3AudioTrack() throws Exception {
+
+        final String audioFilename = INPUT_FILE_PATH +
+            "MP3_48KHz_128kbps_s_1_17.mp3";
+        final int duration = 77640;
+        final int audioBitrate = 128000;
+        final int audioCodecType = MediaProperties.ACODEC_MP3;
+        final int audioSamplingFrequency = 48000;
+        final int audioChannel = 2;
+
+        final AudioTrack audioTrack = mVideoEditorHelper.createAudio
+            (mVideoEditor, "a1", audioFilename);
+
+        validateAudioProperties(audioCodecType, duration, audioSamplingFrequency,
+            audioChannel, audioBitrate, audioTrack);
+    }
+}
diff --git a/media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/functional/VideoEditorAPITest.java b/media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/functional/VideoEditorAPITest.java
new file mode 100644
index 0000000..fb9024d
--- /dev/null
+++ b/media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/functional/VideoEditorAPITest.java
@@ -0,0 +1,2770 @@
+/*
+ * Copyright (C) 2011 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.
+ */
+
+package com.android.mediaframeworktest.functional;
+
+import java.io.File;
+import java.util.List;
+
+import android.graphics.Bitmap;
+import android.graphics.Rect;
+import android.media.videoeditor.AudioTrack;
+import android.media.videoeditor.EffectColor;
+import android.media.videoeditor.EffectKenBurns;
+import android.media.videoeditor.ExtractAudioWaveformProgressListener;
+import android.media.videoeditor.MediaImageItem;
+import android.media.videoeditor.MediaItem;
+import android.media.videoeditor.MediaProperties;
+import android.media.videoeditor.MediaVideoItem;
+import android.media.videoeditor.OverlayFrame;
+import android.media.videoeditor.Transition;
+import android.media.videoeditor.TransitionAlpha;
+import android.media.videoeditor.TransitionCrossfade;
+import android.media.videoeditor.TransitionFadeBlack;
+import android.media.videoeditor.TransitionSliding;
+import android.media.videoeditor.VideoEditor;
+import android.os.Environment;
+import android.test.ActivityInstrumentationTestCase;
+import android.media.videoeditor.VideoEditor.MediaProcessingProgressListener;
+
+import android.util.Log;
+
+import com.android.mediaframeworktest.MediaFrameworkTest;
+import android.test.suitebuilder.annotation.LargeTest;
+import com.android.mediaframeworktest.VideoEditorHelper;
+
+public class VideoEditorAPITest extends
+        ActivityInstrumentationTestCase<MediaFrameworkTest> {
+    private final String TAG = "VideoEditorTest";
+
+    private final String PROJECT_LOCATION = VideoEditorHelper.PROJECT_LOCATION_COMMON;
+
+    private final String INPUT_FILE_PATH = VideoEditorHelper.INPUT_FILE_PATH_COMMON;
+
+    private final String PROJECT_CLASS_NAME =
+        "android.media.videoeditor.VideoEditorImpl";
+    private VideoEditor mVideoEditor;
+    private VideoEditorHelper mVideoEditorHelper;
+
+    public VideoEditorAPITest() {
+        super("com.android.mediaframeworktest", MediaFrameworkTest.class);
+    }
+
+    @Override
+    protected void setUp() throws Exception {
+        // setup for each test case.
+        super.setUp();
+        mVideoEditorHelper = new VideoEditorHelper();
+        // Create a random String which will be used as project path, where all
+        // project related files will be stored.
+        final String projectPath = mVideoEditorHelper.
+            createRandomFile(PROJECT_LOCATION);
+        mVideoEditor = mVideoEditorHelper.createVideoEditor(projectPath);
+    }
+
+    @Override
+    protected void tearDown() throws Exception {
+        mVideoEditorHelper.destroyVideoEditor(mVideoEditor);
+        // Clean the directory created as project path
+        mVideoEditorHelper.deleteProject(new File(mVideoEditor.getPath()));
+        System.gc();
+        super.tearDown();
+    }
+
+    /**
+     * To Test Creation of Media Video Item.
+     */
+    // TODO : remove TC_API_001
+    @LargeTest
+    public void testMediaVideoItem() throws Exception {
+        final String videoItemFileName = INPUT_FILE_PATH
+            + "H263_profile0_176x144_15fps_256kbps_AACLC_32kHz_128kbps_s_0_26.3gp";
+        final int videoItemRenderingMode =
+            MediaItem.RENDERING_MODE_BLACK_BORDER;
+
+        final MediaVideoItem mediaVideoItem1 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "mediaVideoItem1",
+            videoItemFileName, videoItemRenderingMode);
+
+        assertTrue("Media Video ID",
+            mediaVideoItem1.getId().equals("mediaVideoItem1"));
+        assertTrue("Media Video Filename",
+            mediaVideoItem1.getFilename().equals(videoItemFileName));
+        assertEquals("Media Video Rendering Mode",
+            videoItemRenderingMode, mediaVideoItem1.getRenderingMode());
+        assertEquals("Media Video Item Duration", mediaVideoItem1.getDuration(),
+            mediaVideoItem1.getTimelineDuration());
+        assertEquals("Media Video Overlay", 0,
+            mediaVideoItem1.getAllOverlays().size());
+        assertEquals("Media Video Effect", 0,
+            mediaVideoItem1.getAllEffects().size());
+        assertNull("Media Video Begin transition",
+            mediaVideoItem1.getBeginTransition());
+        assertNull("Media Video End transition",
+            mediaVideoItem1.getEndTransition());
+        mediaVideoItem1.setExtractBoundaries(1000,11000);
+        boolean flagForException = false;
+        if (mediaVideoItem1.getDuration() !=
+            mediaVideoItem1.getTimelineDuration()) {
+            flagForException = true;
+        }
+        assertTrue("Media Video Item Duration & Timeline are same",
+            flagForException );
+    }
+
+    /**
+     * To test creation of Media Video Item with Set Extract Boundaries With Get
+     * the Begin and End Time.
+     */
+    // TODO : remove TC_API_002
+    @LargeTest
+    public void testMediaVideoItemExtractBoundaries() throws Exception {
+        final String videoItemFileName = INPUT_FILE_PATH
+            + "H263_profile0_176x144_15fps_256kbps_AACLC_32kHz_128kbps_s_0_26.3gp";
+        final int videoItemRenderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        boolean flagForException = false;
+        final MediaVideoItem mediaVideoItem1 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "mediaVideoItem1",
+            videoItemFileName, videoItemRenderingMode);
+        mVideoEditor.addMediaItem(mediaVideoItem1);
+
+        mediaVideoItem1.setExtractBoundaries(1000, 11000);
+        assertEquals("Media Item Duration = StoryBoard Duration",
+            mediaVideoItem1.getTimelineDuration(), mVideoEditor.getDuration());
+        try {
+            mediaVideoItem1.setExtractBoundaries(0, 100000000);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Set Extract with Invalid Values endTime > FileDuration",
+            flagForException);
+
+        flagForException = false;
+        try {
+            mediaVideoItem1.setExtractBoundaries(100000000, 11000);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Set Extract with Invalid Values startTime > endTime",
+            flagForException);
+
+        flagForException = false;
+        try {
+            mediaVideoItem1.setExtractBoundaries(0, 0);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Set Extract with Invalid Values startTime = endTime",
+            flagForException);
+
+        mediaVideoItem1.setExtractBoundaries(1000, 10000);
+        assertTrue("Media Item Duration is still the same",
+            (mediaVideoItem1.getTimelineDuration() ==
+            (mediaVideoItem1.getBoundaryEndTime()-
+            mediaVideoItem1.getBoundaryBeginTime())) ? true : false);
+
+        mediaVideoItem1.setExtractBoundaries(1,mediaVideoItem1.getDuration()-1);
+        assertEquals("Media Item Start Time", 1,
+            mediaVideoItem1.getBoundaryBeginTime());
+        assertEquals("Media Item End Time", (mediaVideoItem1.getDuration() - 1),
+            mediaVideoItem1.getBoundaryEndTime());
+
+        mediaVideoItem1.setExtractBoundaries(1, mediaVideoItem1.getDuration());
+        assertEquals("Media Item Duration = StoryBoard Duration",
+            mediaVideoItem1.getTimelineDuration(), mVideoEditor.getDuration());
+
+        mediaVideoItem1.setExtractBoundaries(0,mediaVideoItem1.getDuration()/2);
+        assertEquals("Media Item Duration = StoryBoard Duration",
+            mediaVideoItem1.getTimelineDuration(), mVideoEditor.getDuration());
+
+        mediaVideoItem1.setExtractBoundaries(0, -1);
+        assertEquals("Media Item Duration = StoryBoard Duration",
+            mediaVideoItem1.getTimelineDuration(), mVideoEditor.getDuration());
+    }
+
+    /**
+     * To test creation of Media Video Item with Set and Get rendering Mode
+     */
+    // TODO : remove TC_API_003
+    @LargeTest
+    public void testMediaVideoItemRenderingModes() throws Exception {
+        final String videoItemFileName = INPUT_FILE_PATH
+            + "H263_profile0_176x144_15fps_256kbps_AACLC_32kHz_128kbps_s_0_26.3gp";
+        final int videoItemRenderingMode= MediaItem.RENDERING_MODE_BLACK_BORDER;
+        boolean flagForException = false;
+        final MediaVideoItem mediaVideoItem1 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "mediaVideoItem1",
+            videoItemFileName, videoItemRenderingMode);
+        mVideoEditor.addMediaItem(mediaVideoItem1);
+        mediaVideoItem1.setRenderingMode(MediaItem.RENDERING_MODE_CROPPING);
+        assertEquals("MediaVideo Item rendering Mode",
+            MediaItem.RENDERING_MODE_CROPPING,
+            mediaVideoItem1.getRenderingMode());
+        try {
+            mediaVideoItem1.setRenderingMode(
+                MediaItem.RENDERING_MODE_CROPPING + 911);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Media Item Invalid rendering Mode", flagForException);
+        flagForException = false;
+        try {
+            mediaVideoItem1.setRenderingMode(
+                MediaItem.RENDERING_MODE_BLACK_BORDER - 11);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Media Item Invalid rendering Mode", flagForException);
+        assertEquals("MediaVideo Item rendering Mode",
+            MediaItem.RENDERING_MODE_CROPPING,
+            mediaVideoItem1.getRenderingMode());
+        mediaVideoItem1.setRenderingMode(MediaItem.RENDERING_MODE_STRETCH);
+        assertEquals("MediaVideo Item rendering Mode",
+            MediaItem.RENDERING_MODE_STRETCH,
+            mediaVideoItem1.getRenderingMode());
+    }
+
+    /** Test Case  TC_API_004 is removed */
+
+    /**
+     * To Test the Media Video API : Set Audio Volume, Get Audio Volume and Mute
+     */
+    // TODO : remove TC_API_005
+    @LargeTest
+    public void testMediaVideoItemAudioFeatures() throws Exception {
+        final String videoItemFileName = INPUT_FILE_PATH
+            + "H263_profile0_176x144_15fps_256kbps_AACLC_32kHz_128kbps_s_0_26.3gp";
+        final int videoItemRenderingMode =MediaItem.RENDERING_MODE_BLACK_BORDER;
+        boolean flagForException = false;
+        final MediaVideoItem mediaVideoItem1 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "mediaVideoItem1",
+            videoItemFileName, videoItemRenderingMode);
+        mVideoEditor.addMediaItem(mediaVideoItem1);
+        mediaVideoItem1.setVolume(77);
+        assertEquals("Updated Volume is 77", 77, mediaVideoItem1.getVolume());
+
+        mediaVideoItem1.setMute(true);
+        assertTrue("Audio must be Muted", mediaVideoItem1.isMuted());
+
+        mediaVideoItem1.setVolume(78);
+        assertEquals("Updated Volume is 78", 78, mediaVideoItem1.getVolume());
+        assertTrue("Audio must be Muted", mediaVideoItem1.isMuted());
+
+        try {
+            mediaVideoItem1.setVolume(1000);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Invalid Set Volume", flagForException);
+
+        mediaVideoItem1.setMute(false);
+        assertFalse("Audio must be Un-Muted", mediaVideoItem1.isMuted());
+
+        mediaVideoItem1.setVolume(0);
+        assertFalse("Audio must be Un-Muted", mediaVideoItem1.isMuted());
+
+        flagForException = false;
+        try {
+            mediaVideoItem1.setVolume(-1);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Invalid Set Volume", flagForException);
+
+        mediaVideoItem1.setVolume(100);
+        assertEquals("MediaItem Volume", 100, mediaVideoItem1.getVolume());
+        try {
+            mediaVideoItem1.setVolume(101);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Invalid Set Volume", flagForException);
+        assertEquals("MediaItem Volume", 100, mediaVideoItem1.getVolume());
+    }
+
+    /**
+     * To Test the Media Video API : GetWaveFormData and
+     * extractAudioWaveFormData
+     */
+
+    // TODO : remove TC_API_006
+    @LargeTest
+    public void testMediaVideoItemGetWaveformData() throws Exception {
+
+        final String videoItemFileName = INPUT_FILE_PATH
+            + "H263_profile0_176x144_15fps_256kbps_AACLC_32kHz_128kbps_s_0_26.3gp";
+        final int videoItemRenderingMode =MediaItem.RENDERING_MODE_BLACK_BORDER;
+        final MediaVideoItem mediaVideoItem1 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "mediaVideoItem1",
+            videoItemFileName, videoItemRenderingMode);
+        mVideoEditor.addMediaItem(mediaVideoItem1);
+
+        assertNull("WaveForm data", mediaVideoItem1.getWaveformData());
+        final int[] progressWaveform = new int[105];
+
+        mediaVideoItem1.extractAudioWaveform(new
+            ExtractAudioWaveformProgressListener() {
+                int i = 0;
+                public void onProgress(int progress) {
+                    Log.i("WaveformData","progress=" +progress);
+                    progressWaveform[i++] = progress;
+                }
+            });
+        assertTrue("Progress of WaveForm data", mVideoEditorHelper
+            .checkProgressCBValues(progressWaveform));
+        assertNotNull("WaveForm data", mediaVideoItem1.getWaveformData());
+        assertTrue("WaveForm Frame Duration",
+            (mediaVideoItem1.getWaveformData().getFrameDuration() > 0?
+            true : false));
+        assertTrue("WaveForm Frame Count",
+            (mediaVideoItem1.getWaveformData().getFramesCount() > 0 ?
+            true : false));
+        assertTrue("WaveForm Gain",
+            (mediaVideoItem1.getWaveformData().getFrameGains().length > 0 ?
+            true : false));
+
+    }
+
+    /**
+     * To Test the Media Video API : Get Effect, GetAllEffects, remove Effect
+     */
+
+    // TODO : remove TC_API_007
+    @LargeTest
+    public void testMediaVideoItemEffect() throws Exception {
+        final String videoItemFileName = INPUT_FILE_PATH
+            + "H263_profile0_176x144_15fps_256kbps_AACLC_32kHz_128kbps_s_0_26.3gp";
+        final int videoItemRenderingMode =MediaItem.RENDERING_MODE_BLACK_BORDER;
+        final MediaVideoItem mediaVideoItem1 = mVideoEditorHelper.
+            createMediaItem(mVideoEditor, "mediaVideoItem1", videoItemFileName,
+            videoItemRenderingMode);
+        mVideoEditor.addMediaItem(mediaVideoItem1);
+
+        assertTrue("Effect List Size",
+            (mediaVideoItem1.getAllEffects().size() == 0) ? true : false);
+        assertNull("Effect Item by ID", mediaVideoItem1.getEffect("xyx"));
+
+        final EffectColor effectColor = mVideoEditorHelper.createEffectItem(
+            mediaVideoItem1, "Effecton MVi1", 0, 4000, EffectColor.TYPE_GRADIENT,
+            EffectColor.GRAY);
+        mediaVideoItem1.addEffect(effectColor);
+
+        assertTrue("Effect List Size", (mediaVideoItem1.
+            getAllEffects().size() == 1) ? true : false);
+        assertEquals("Effect Item by Valid ID", effectColor,
+            mediaVideoItem1.getEffect(effectColor.getId()));
+        assertNull("Effect Item by Invalid ID",
+            mediaVideoItem1.getEffect("xyz"));
+        assertNull("Effect Item by Invalid ID",
+            mediaVideoItem1.removeEffect("effectId"));
+        assertTrue("Effect List Size",
+            (mediaVideoItem1.getAllEffects().size() == 1) ? true : false);
+        assertEquals("Effect Removed", effectColor,
+            mediaVideoItem1.removeEffect(effectColor.getId()));
+        assertTrue("Effect List Size",
+            (mediaVideoItem1.getAllEffects().size() == 0) ? true : false);
+        assertNull("Effect Item by ID", mediaVideoItem1.getEffect("effectId"));
+    }
+
+    /**
+     * To Test the Media Video API : Get Before and after transition
+     */
+
+    // TODO : remove TC_API_008
+    @LargeTest
+    public void testMediaVideoItemTransitions() throws Exception {
+        final String videoItemFileName = INPUT_FILE_PATH
+            + "H263_profile0_176x144_15fps_256kbps_AACLC_32kHz_128kbps_s_0_26.3gp";
+        final int videoItemRenderingMode =MediaItem.RENDERING_MODE_BLACK_BORDER;
+        final MediaVideoItem mediaVideoItem1 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "mediaVideoItem1",
+            videoItemFileName, videoItemRenderingMode);
+        mVideoEditor.addMediaItem(mediaVideoItem1);
+        assertNull("Begin Transition", mediaVideoItem1.getBeginTransition());
+        assertNull("End Transition", mediaVideoItem1.getEndTransition());
+
+        TransitionFadeBlack transition1 =
+            mVideoEditorHelper.createTFadeBlack("transition1", mediaVideoItem1,
+            null, 0, Transition.BEHAVIOR_SPEED_UP);
+        mVideoEditor.addTransition(transition1);
+        assertEquals("Begin transition", transition1,
+            mediaVideoItem1.getEndTransition());
+
+        assertNotNull("End Transition", mediaVideoItem1.getEndTransition());
+        assertTrue(mediaVideoItem1.
+            getEndTransition().getId().equals(transition1.getId()));
+        assertTrue(mediaVideoItem1.getEndTransition().getDuration() ==
+            transition1.getDuration() ? true : false);
+        assertTrue(mediaVideoItem1.getEndTransition().getBehavior() ==
+            transition1.getBehavior() ? true : false);
+
+        TransitionFadeBlack transition2 = mVideoEditorHelper.createTFadeBlack(
+            "transition2", null,mediaVideoItem1, 0, Transition.BEHAVIOR_LINEAR);
+        mVideoEditor.addTransition(transition2);
+        assertNotNull("Begin transition", mediaVideoItem1.getBeginTransition());
+        assertEquals("End Transition", transition2,
+            mediaVideoItem1.getBeginTransition());
+        assertTrue(mediaVideoItem1.
+            getBeginTransition().getId().equals(transition2.getId()));
+        assertTrue(mediaVideoItem1. getBeginTransition().getDuration() ==
+            transition2.getDuration() ? true : false);
+        assertTrue(mediaVideoItem1.getBeginTransition().getBehavior() ==
+            transition2.getBehavior() ? true : false);
+    }
+
+    /**
+     * To Test the Media Video API : Get All Overlay, Get Overlay and remove Overlay
+     *
+     */
+
+    // TODO : remove TC_API_009
+    @LargeTest
+    public void testMediaVideoItemOverlays() throws Exception {
+        final String videoItemFileName = INPUT_FILE_PATH
+            + "H263_profile0_176x144_15fps_256kbps_AACLC_32kHz_128kbps_s_0_26.3gp";
+        final String overlayItemFileName = INPUT_FILE_PATH +
+            "IMG_176x144_Overlay1.png";
+        final int videoItemRenderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        final MediaVideoItem mediaVideoItem1 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "mediaVideoItem1",
+            videoItemFileName, videoItemRenderingMode);
+        mVideoEditor.addMediaItem(mediaVideoItem1);
+
+        assertTrue("Overlay List Size",
+            (mediaVideoItem1.getAllOverlays().size() == 0) ? true : false);
+        assertNull("Overlay Item by ID", mediaVideoItem1.getOverlay("xyz"));
+
+        final Bitmap mBitmap =  mVideoEditorHelper.getBitmap(overlayItemFileName,
+            176, 144);
+        final OverlayFrame overlayFrame = mVideoEditorHelper.createOverlay(
+            mediaVideoItem1, "overlayId", mBitmap, 5000, 5000);
+        mediaVideoItem1.addOverlay(overlayFrame);
+
+        assertTrue("Overlay List Size",
+            (mediaVideoItem1.getAllOverlays().size() == 1) ? true : false);
+        assertEquals("Overlay Item by Valid ID", overlayFrame, mediaVideoItem1
+            .getOverlay(overlayFrame.getId()));
+        assertNull("Overlay Item by Invalid ID",
+            mediaVideoItem1.getOverlay("xyz"));
+        assertNull("Overlay Item by Invalid ID",
+            mediaVideoItem1.removeOverlay("xyz"));
+        assertTrue("Overlay List Size",
+            (mediaVideoItem1.getAllOverlays().size() == 1) ? true : false);
+        assertEquals("Overlay Removed", overlayFrame,
+            mediaVideoItem1.removeOverlay(overlayFrame.getId()));
+        assertTrue("Overlay List Size",
+            (mediaVideoItem1.getAllOverlays().size() == 0) ? true : false);
+        assertNull("Overlay Item by ID",mediaVideoItem1.getOverlay("effectId"));
+    }
+
+    /**
+     * To Test Creation of Media Image Item.
+     */
+    // TODO : remove TC_API_010
+    @LargeTest
+    public void testMediaImageItem() throws Exception {
+        final String imageItemFileName = INPUT_FILE_PATH + "IMG_1600x1200.jpg";
+        final int imageItemRenderingMode =MediaItem.RENDERING_MODE_BLACK_BORDER;
+        final MediaImageItem mediaImageItem1 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "mediaImageItem1",
+                imageItemFileName, 5000, imageItemRenderingMode);
+        assertTrue("Media Image ID",
+            mediaImageItem1.getId().equals("mediaImageItem1"));
+        assertTrue("Media IMage Filename",
+            mediaImageItem1.getFilename().equals(imageItemFileName));
+        assertEquals("Media Image Rendering Mode",
+            imageItemRenderingMode, mediaImageItem1.getRenderingMode());
+        assertEquals("Media Image Item Duration", mediaImageItem1.getDuration(),
+            mediaImageItem1.getTimelineDuration());
+        assertEquals("Media Image Overlay", 0,
+            mediaImageItem1.getAllOverlays().size());
+        assertEquals("Media Image Effect", 0,
+            mediaImageItem1.getAllEffects().size());
+        assertNull("Media Image Begin transition",
+            mediaImageItem1.getBeginTransition());
+        assertNull("Media Image End transition",
+            mediaImageItem1.getEndTransition());
+        assertEquals("Media Image Scaled Height", MediaProperties.HEIGHT_720,
+            mediaImageItem1.getScaledHeight());
+        assertEquals("Media Image Scaled Width", 960,
+            mediaImageItem1.getScaledWidth());
+        assertEquals("Media Image Aspect Ratio", MediaProperties.ASPECT_RATIO_4_3,
+            mediaImageItem1.getAspectRatio());
+        assertNotNull("Media Image Thumbnail",
+            mediaImageItem1.getThumbnail(960, MediaProperties.HEIGHT_720, 2000));
+    }
+
+    /**
+     * To Test the Media Image API : Get and Set rendering Mode
+     */
+    // TODO : remove TC_API_011
+    @LargeTest
+    public void testMediaImageItemRenderingModes() throws Exception {
+        final String imageItemFileName = INPUT_FILE_PATH + "IMG_1600x1200.jpg";
+        final int imageItemRenderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        boolean flagForException = false;
+        final MediaImageItem mediaImageItem1 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "mediaImageItem1",
+            imageItemFileName, imageItemRenderingMode, 5000);
+        mVideoEditor.addMediaItem(mediaImageItem1);
+
+        mediaImageItem1.setRenderingMode(MediaItem.RENDERING_MODE_CROPPING);
+        assertEquals("MediaVideo Item rendering Mode",
+            MediaItem.RENDERING_MODE_CROPPING, mediaImageItem1.getRenderingMode());
+        try {
+            mediaImageItem1.setRenderingMode(
+                MediaItem.RENDERING_MODE_CROPPING + 911);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Media Item Invalid rendering Mode", flagForException);
+
+        flagForException = false;
+        try {
+            mediaImageItem1.setRenderingMode(
+                MediaItem.RENDERING_MODE_BLACK_BORDER - 11);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Media Item Invalid rendering Mode", flagForException);
+
+        assertEquals("MediaVideo Item rendering Mode",
+            MediaItem.RENDERING_MODE_CROPPING,
+            mediaImageItem1.getRenderingMode());
+        mediaImageItem1.setRenderingMode(MediaItem.RENDERING_MODE_STRETCH);
+        assertEquals("MediaVideo Item rendering Mode",
+            MediaItem.RENDERING_MODE_STRETCH,
+            mediaImageItem1.getRenderingMode());
+    }
+
+    /**
+     * To Test the Media Image API : GetHeight and GetWidth
+     */
+    // TODO : remove TC_API_012
+    @LargeTest
+    public void testMediaImageItemHeightWidth() throws Exception {
+        final String imageItemFileName = INPUT_FILE_PATH + "IMG_640x480.jpg";
+        final int imageItemRenderingMode =MediaItem.RENDERING_MODE_BLACK_BORDER;
+        final MediaImageItem mediaImageItem1 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "mediaImageItem1",
+            imageItemFileName, imageItemRenderingMode, 5000);
+        mVideoEditor.addMediaItem(mediaImageItem1);
+
+        assertEquals("Image Height = Image Scaled Height",
+            mediaImageItem1.getScaledHeight(), mediaImageItem1.getHeight());
+        assertEquals("Image Width = Image Scaled Width",
+            mediaImageItem1.getScaledWidth(), mediaImageItem1.getWidth());
+    }
+
+
+
+/**    This Test Case can be removed as this is already checked in TC 010 */
+    /**
+     * To Test the Media Image API : Scaled Height and Scaled GetWidth
+     */
+    // TODO : remove TC_API_013
+    @LargeTest
+    public void testMediaImageItemScaledHeightWidth() throws Exception {
+        final String imageItemFileName = INPUT_FILE_PATH + "IMG_1600x1200.jpg";
+        final int imageItemRenderingMode =MediaItem.RENDERING_MODE_BLACK_BORDER;
+
+        final MediaImageItem mediaImageItem1 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "mediaImageItem1",
+            imageItemFileName, imageItemRenderingMode, 5000);
+        mVideoEditor.addMediaItem(mediaImageItem1);
+
+        assertNotSame("Image Height = Image Scaled Height",
+            mediaImageItem1.getScaledHeight(), mediaImageItem1.getHeight());
+        assertNotSame("Image Width = Image Scaled Width",
+            mediaImageItem1.getScaledWidth(), mediaImageItem1.getWidth());
+    }
+
+    /**
+     * To Test the Media Image API : Get Effect, GetAllEffects, remove Effect
+     */
+
+    // TODO : remove TC_API_014
+    @LargeTest
+    public void testMediaImageItemEffect() throws Exception {
+        final String imageItemFileName = INPUT_FILE_PATH + "IMG_1600x1200.jpg";
+        final int imageItemRenderingMode =MediaItem.RENDERING_MODE_BLACK_BORDER;
+        final MediaImageItem mediaImageItem1 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "mediaImageItem1",
+            imageItemFileName, 5000, imageItemRenderingMode);
+        mVideoEditor.addMediaItem(mediaImageItem1);
+
+        assertTrue("Effect List Size",
+            (mediaImageItem1.getAllEffects().size() == 0) ? true : false);
+        assertNull("Effect Item by ID", mediaImageItem1.getEffect("xyx"));
+
+        final EffectColor effectColor =
+            mVideoEditorHelper.createEffectItem(mediaImageItem1,
+            "Effecton MVi1", 0, 4000, EffectColor.TYPE_GRADIENT, EffectColor.GRAY);
+        mediaImageItem1.addEffect(effectColor);
+
+        assertTrue("Effect List Size",
+            (mediaImageItem1.getAllEffects().size() == 1) ? true : false);
+        assertEquals("Effect Item by Valid ID",
+            effectColor, mediaImageItem1.getEffect(effectColor.getId()));
+        assertNull("Effect Item by Invalid ID",
+            mediaImageItem1.getEffect("xyz"));
+        assertNull("Effect Item by Invalid ID",
+            mediaImageItem1.removeEffect("effectId"));
+        assertTrue("Effect List Size",
+            (mediaImageItem1.getAllEffects().size() == 1) ? true : false);
+        assertEquals("Effect Removed", effectColor,
+            mediaImageItem1.removeEffect(effectColor.getId()));
+        assertTrue("Effect List Size",
+            (mediaImageItem1.getAllEffects().size() == 0) ? true : false);
+        assertNull("Effect Item by ID", mediaImageItem1.getEffect("effectId"));
+    }
+
+    /**
+     * To Test the Media Image API : Get Before and after transition
+     */
+
+    // TODO : remove TC_API_015
+    @LargeTest
+    public void testMediaImageItemTransitions() throws Exception {
+        final String imageItemFileName = INPUT_FILE_PATH + "IMG_1600x1200.jpg";
+        final int imageItemRenderingMode =MediaItem.RENDERING_MODE_BLACK_BORDER;
+        final MediaImageItem mediaImageItem1 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "mediaImageItem1",
+            imageItemFileName, 5000, imageItemRenderingMode);
+        mVideoEditor.addMediaItem(mediaImageItem1);
+
+        assertNull("Begin Transition", mediaImageItem1.getBeginTransition());
+        assertNull("End Transition", mediaImageItem1.getEndTransition());
+
+        TransitionFadeBlack transition1 =
+            mVideoEditorHelper.createTFadeBlack("transition1", mediaImageItem1,
+            null, 0, Transition.BEHAVIOR_SPEED_UP);
+        mVideoEditor.addTransition(transition1);
+
+        assertEquals("Begin transition", transition1,
+            mediaImageItem1.getEndTransition());
+        assertNotNull("End Transition", mediaImageItem1.getEndTransition());
+        assertTrue(mediaImageItem1.getEndTransition().getId().equals
+            (transition1.getId()));
+        assertTrue(mediaImageItem1.getEndTransition().getDuration() ==
+            transition1.getDuration() ? true : false);
+        assertTrue(mediaImageItem1.getEndTransition().getBehavior() ==
+            transition1.getBehavior() ? true : false);
+
+        TransitionFadeBlack transition2 = mVideoEditorHelper.createTFadeBlack(
+            "transition2",null, mediaImageItem1, 0, Transition.BEHAVIOR_SPEED_UP);
+        mVideoEditor.addTransition(transition2);
+
+        assertNotNull("Begin transition", mediaImageItem1.getBeginTransition());
+        assertEquals("End Transition", transition2,
+            mediaImageItem1.getBeginTransition());
+        assertTrue(mediaImageItem1.getBeginTransition().getId().equals(
+            transition2.getId()));
+        assertTrue(mediaImageItem1.getBeginTransition().getDuration() ==
+            transition2.getDuration() ? true : false);
+        assertTrue(mediaImageItem1.getBeginTransition().getBehavior() ==
+            transition2.getBehavior() ? true : false);
+    }
+
+    /**
+     * To Test the Media Image API : Get All Overlay, Get Overlay and remove
+     * Overlay
+     */
+
+    // TODO : remove TC_API_016
+    @LargeTest
+    public void testMediaImageItemOverlays() throws Exception {
+        final String imageItemFileName = INPUT_FILE_PATH + "IMG_640x480.jpg";
+        final String overlayItemFileName = INPUT_FILE_PATH +
+            "IMG_640x480_Overlay1.png";
+        final int imageItemRenderingMode =MediaItem.RENDERING_MODE_BLACK_BORDER;
+        final MediaImageItem mediaImageItem1 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "mediaImageItem1",
+            imageItemFileName, 12000, imageItemRenderingMode);
+        mVideoEditor.addMediaItem(mediaImageItem1);
+
+        assertTrue("Overlay List Size",
+            (mediaImageItem1.getAllOverlays().size() == 0) ? true : false);
+        assertNull("Overlay Item by ID", mediaImageItem1.getOverlay("xyz"));
+        final Bitmap mBitmap =  mVideoEditorHelper.getBitmap(overlayItemFileName,
+            640, 480);
+        final OverlayFrame overlayFrame =
+            mVideoEditorHelper.createOverlay(mediaImageItem1, "overlayId",
+            mBitmap, 5000, 5000);
+        mediaImageItem1.addOverlay(overlayFrame);
+
+        assertTrue("Overlay List Size",
+            (mediaImageItem1.getAllOverlays().size() == 1) ? true : false);
+        assertEquals("Overlay Item by Valid ID", overlayFrame, mediaImageItem1
+            .getOverlay(overlayFrame.getId()));
+        assertNull("Overlay Item by Invalid ID",
+            mediaImageItem1.getOverlay("xyz"));
+        assertNull("Remove Overlay Item by Invalid ID",
+            mediaImageItem1.removeOverlay("xyz"));
+        assertTrue("Overlay List Size",
+            (mediaImageItem1.getAllOverlays().size() == 1) ? true : false);
+        assertEquals("Overlay Removed",
+            overlayFrame, mediaImageItem1.removeOverlay(overlayFrame.getId()));
+        assertTrue("Overlay List Size",
+            (mediaImageItem1.getAllOverlays().size() == 0) ? true : false);
+        assertNull("Overlay Item by ID",
+            mediaImageItem1.getOverlay("effectId"));
+    }
+
+    /**
+     * To test creation of Audio Track
+     */
+
+    // TODO : remove TC_API_017
+    @LargeTest
+    public void testAudioTrack() throws Exception {
+        final String audioFileName = INPUT_FILE_PATH +
+            "AACLC_48KHz_256Kbps_s_1_17.3gp";
+        final AudioTrack audioTrack = mVideoEditorHelper.createAudio(
+            mVideoEditor, "audioTrack", audioFileName);
+        mVideoEditor.addAudioTrack(audioTrack);
+
+        assertEquals("Audio Track Item Duration", audioTrack.getDuration(),
+            audioTrack.getTimelineDuration());
+        assertEquals("Audio Track Start Time", 0, audioTrack.getStartTime());
+        assertFalse("Audio Track is Looping", audioTrack.isLooping());
+        audioTrack.getVolume();
+        assertFalse("Audio Track Ducking is Disabled",
+            audioTrack.isDuckingEnabled());
+        assertTrue("Audio Track Filename",
+            audioTrack.getFilename().equals(audioFileName));
+         assertEquals("Audio Ducking Threshold", 0,
+            audioTrack.getDuckingThreshhold());
+         assertFalse("Audio Track Mute", audioTrack.isMuted());
+         audioTrack.getDuckedTrackVolume();
+    }
+
+    /**
+     * To test creation of Audio Track with set extract boundaries
+     */
+    // TODO : remove TC_API_018
+    @LargeTest
+    public void testAudioTrackExtractBoundaries() throws Exception {
+        final String audioFileName = INPUT_FILE_PATH +
+            "AACLC_48KHz_256Kbps_s_1_17.3gp";
+        boolean flagForException = false;
+        final AudioTrack audioTrack = mVideoEditorHelper.createAudio(
+            mVideoEditor, "audioTrack", audioFileName);
+        mVideoEditor.addAudioTrack(audioTrack);
+
+        audioTrack.setExtractBoundaries(1000, 5000);
+        assertEquals("Audio Track Start time", 1000,
+            audioTrack.getBoundaryBeginTime());
+        assertEquals("Audio Track End time", 5000,
+            audioTrack.getBoundaryEndTime());
+        try {
+            audioTrack.setExtractBoundaries(0, 100000000);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Audio Track With endTime > FileDuration", flagForException);
+        flagForException = false;
+        try {
+            audioTrack.setExtractBoundaries(100000000, 5000);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Audio Track With startTime > FileDuration",
+            flagForException);
+        flagForException = false;
+        try {
+            audioTrack.setExtractBoundaries(0, 0);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        /* This is under discussion.  Hence, checked for False */
+        assertFalse("Audio Track With startTime = endTime", flagForException);
+        assertEquals("Audio Track Start time", 0,
+            audioTrack.getBoundaryBeginTime());
+        assertEquals("Audio Track End time", 0,
+            audioTrack.getBoundaryEndTime());
+        assertEquals("Audio Track Start time",0,
+            audioTrack.getBoundaryBeginTime());
+        assertEquals("Audio Track End time", (audioTrack.getTimelineDuration()),
+            audioTrack.getBoundaryEndTime());
+        audioTrack.setExtractBoundaries(0, audioTrack.getDuration() / 2);
+        assertEquals("Audio Track Start time",0,
+            audioTrack.getBoundaryBeginTime());
+        assertEquals("Audio Track End time", (audioTrack.getDuration() / 2),
+            audioTrack.getBoundaryEndTime());
+        audioTrack.setExtractBoundaries(1, audioTrack.getDuration() - 1);
+        assertEquals("Audio Track Start time", 1,
+            audioTrack.getBoundaryBeginTime());
+        assertEquals("Audio Track End time", (audioTrack.getDuration() - 1),
+            audioTrack.getBoundaryEndTime());
+
+        flagForException = false;
+        try {
+                audioTrack.setExtractBoundaries(0, -1);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue ("Audio Track end time < 0",flagForException);
+    }
+
+    /**
+     * To test creation of Audio Track with set Start Time and Get Time
+     */
+    // TODO : remove TC_API_019
+    @LargeTest
+    public void testAudioTrackSetGetTime() throws Exception {
+        final String audioFileName = INPUT_FILE_PATH +
+            "AACLC_48KHz_256Kbps_s_1_17.3gp";
+        boolean flagForException = false;
+        final AudioTrack audioTrack = mVideoEditorHelper.createAudio(
+            mVideoEditor, "audioTrack", audioFileName);
+        mVideoEditor.addAudioTrack(audioTrack);
+        /** set StartTime API is removed and start time is always 0 */
+        assertEquals("Audio Track Start Time", 0, audioTrack.getStartTime());
+    }
+
+    /**
+     * To Test the Audio Track API: Enable Ducking
+     */
+    // TODO : remove TC_API_020
+    @LargeTest
+    public void testAudioTrackEnableDucking() throws Exception {
+        final String audioFileName = INPUT_FILE_PATH +
+            "AACLC_48KHz_256Kbps_s_1_17.3gp";
+        boolean flagForException = false;
+        final AudioTrack audioTrack = mVideoEditorHelper.createAudio(
+            mVideoEditor, "audioTrack", audioFileName);
+        mVideoEditor.addAudioTrack(audioTrack);
+
+        assertFalse("Audio Ducking Disabled by default",
+            audioTrack.isDuckingEnabled());
+        audioTrack.enableDucking(45, 70);
+        assertTrue("Audio Ducking Enabled", audioTrack.isDuckingEnabled());
+        assertEquals("Audio Ducking Threshold", 45,
+            audioTrack.getDuckingThreshhold());
+        assertEquals("Audio Ducking Volume", 70,
+            audioTrack.getDuckedTrackVolume());
+        audioTrack.enableDucking(85, 70);
+        assertEquals("Audio Ducking Threshold", 85,
+            audioTrack.getDuckingThreshhold());
+        assertEquals("Audio Ducking Volume", 70,
+            audioTrack.getDuckedTrackVolume());
+        try {
+            audioTrack.enableDucking(91, 70);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Enable ducking threshold > 90", flagForException);
+        flagForException = false;
+        try {
+            audioTrack.enableDucking(90, 101);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Enable ducking volume > 100", flagForException);
+        flagForException = false;
+        try {
+            audioTrack.enableDucking(91, 101);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Enable ducking volume > 100 and threshold > 91",
+            flagForException);
+        flagForException = false;
+        try {
+            audioTrack.enableDucking(-1, 100);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Enable ducking threshold < 0", flagForException);
+        flagForException = false;
+        try {
+            audioTrack.enableDucking(1, -1);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Enable ducking lowVolume < 0", flagForException);
+        flagForException = false;
+        try {
+            audioTrack.enableDucking(0, 50);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertFalse("Enable ducking threshold = 0", flagForException);
+    }
+
+    /**
+     * To Test the Audio Track API: Looping
+     */
+    // TODO : remove TC_API_021
+    @LargeTest
+    public void testAudioTrackLooping() throws Exception {
+        final String audioFileName = INPUT_FILE_PATH +
+            "AACLC_48KHz_256Kbps_s_1_17.3gp";
+        final AudioTrack audioTrack = mVideoEditorHelper.createAudio(
+            mVideoEditor, "audioTrack", audioFileName);
+        mVideoEditor.addAudioTrack(audioTrack);
+        assertFalse("Audio Looping", audioTrack.isLooping());
+        audioTrack.enableLoop();
+        assertTrue("Audio Looping", audioTrack.isLooping());
+        audioTrack.disableLoop();
+        assertFalse("Audio Looping", audioTrack.isLooping());
+    }
+
+    /**
+     * To Test the Audio Track API:Extract waveform data
+     */
+    // TODO : remove TC_API_022
+    @LargeTest
+    public void testAudioTrackWaveFormData() throws Exception {
+
+        final String audioFileName = INPUT_FILE_PATH +
+            "AACLC_48KHz_256Kbps_s_1_17.3gp";
+        final AudioTrack audioTrack = mVideoEditorHelper.createAudio(
+            mVideoEditor, "audioTrack", audioFileName);
+
+        mVideoEditor.addAudioTrack(audioTrack);
+        assertNull("WaveForm data", audioTrack.getWaveformData());
+
+        final int[] progressUpdate = new int[105];
+        mVideoEditor.generatePreview(new MediaProcessingProgressListener() {
+            int i = 0;
+            public void onProgress(Object item, int action, int progress) {
+                progressUpdate[i++] = progress;
+            }
+        });
+
+        final int[] progressWaveform = new int[105];
+
+        audioTrack.extractAudioWaveform(
+            new ExtractAudioWaveformProgressListener() {
+                int i = 0;
+                public void onProgress(int progress) {
+                    Log.i("AudioWaveformData","progress=" +progress);
+                    progressWaveform[i++] = progress;
+            }
+        });
+        assertTrue("Progress of WaveForm data", mVideoEditorHelper
+            .checkProgressCBValues(progressWaveform));
+        assertNotNull("WaveForm data", audioTrack.getWaveformData());
+        assertTrue("WaveForm Frame Duration",
+            (audioTrack.getWaveformData().getFrameDuration() > 0 ?
+            true : false));
+        assertTrue("WaveForm Frame Count",
+            (audioTrack.getWaveformData().getFramesCount() > 0 ? true : false));
+        assertTrue("WaveForm Gain",
+            (audioTrack.getWaveformData().getFrameGains().length > 0 ?
+            true : false));
+    }
+
+    /**
+     * To Test the Audio Track API: Mute
+     */
+    // TODO : remove TC_API_023
+    @LargeTest
+    public void testAudioTrackMute() throws Exception {
+        final String audioFileName = INPUT_FILE_PATH +
+            "AACLC_48KHz_256Kbps_s_1_17.3gp";
+        final AudioTrack audioTrack = mVideoEditorHelper.createAudio(
+            mVideoEditor, "audioTrack", audioFileName);
+        assertFalse("Audio Track UnMute", audioTrack.isMuted());
+        audioTrack.setMute(true);
+        assertTrue("Audio Track Mute", audioTrack.isMuted());
+        audioTrack.setMute(false);
+        assertFalse("Audio Track UnMute", audioTrack.isMuted());
+    }
+
+    /**
+     * To Test the Audio Track API: Get Volume and Set Volume
+     */
+    // TODO : remove TC_API_024
+    @LargeTest
+    public void testAudioTrackGetSetVolume() throws Exception {
+        final String audioFileName = INPUT_FILE_PATH +
+            "AACLC_48KHz_256Kbps_s_1_17.3gp";
+        boolean flagForException = false;
+        final AudioTrack audioTrack = mVideoEditorHelper.createAudio(
+            mVideoEditor, "audioTrack", audioFileName);
+        audioTrack.setVolume(0);
+        assertEquals("Audio Volume", 0, audioTrack.getVolume());
+        assertFalse("Audio Track UnMute", audioTrack.isMuted());
+        audioTrack.setVolume(45);
+        assertEquals("Audio Volume", 45, audioTrack.getVolume());
+        assertFalse("Audio Track UnMute", audioTrack.isMuted());
+        try {
+            audioTrack.setVolume(-1);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Volume = -1", flagForException);
+        assertEquals("Audio Volume", 45, audioTrack.getVolume());
+        flagForException = false;
+        try {
+            audioTrack.setVolume(101);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Volume = 101", flagForException);
+        flagForException = false;
+        try {
+            audioTrack.setVolume(1000);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Volume = 10000", flagForException);
+        assertEquals("Audio Volume", 45, audioTrack.getVolume());
+    }
+
+    /**
+     * To test Effect Color.
+     */
+    // TODO : remove TC_API_025
+    @LargeTest
+    public void testAllEffects() throws Exception {
+        final String videoItemFileName = INPUT_FILE_PATH +
+            "MPEG4_SP_640x480_30fps_512Kbps_0_27.mp4";
+        boolean flagForException = false;
+        final MediaVideoItem mediaVideoItem1 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "mediaVideoItem1",
+            videoItemFileName, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mVideoEditor.addMediaItem(mediaVideoItem1);
+
+        final EffectColor effectColor1 = mVideoEditorHelper.createEffectItem(
+            mediaVideoItem1, "effect1", 1000, 1000, EffectColor.TYPE_COLOR,
+            EffectColor.PINK);
+        mediaVideoItem1.addEffect(effectColor1);
+
+        assertEquals("Associated Media Item", mediaVideoItem1,
+            effectColor1.getMediaItem());
+        assertTrue("Effect Id", effectColor1.getId().equals("effect1"));
+        assertEquals("Effect StartTime", 1000, effectColor1.getStartTime());
+        assertEquals("Effect EndTime", 1000, effectColor1.getDuration());
+        assertEquals("Effect Type", EffectColor.TYPE_COLOR,
+            effectColor1.getType());
+        assertEquals("Effect Color", EffectColor.PINK, effectColor1.getColor());
+
+        final EffectColor effectColor2 = mVideoEditorHelper.createEffectItem(
+            mediaVideoItem1, "effect2", 2000, 1000, EffectColor.TYPE_COLOR,
+            EffectColor.GRAY);
+        mediaVideoItem1.addEffect(effectColor2);
+
+        assertEquals("Associated Media Item", mediaVideoItem1,
+            effectColor2.getMediaItem());
+        assertTrue("Effect Id", effectColor2.getId().equals("effect2"));
+        assertEquals("Effect StartTime", 2000, effectColor2.getStartTime());
+        assertEquals("Effect EndTime", 1000, effectColor2.getDuration());
+        assertEquals("Effect Type", EffectColor.TYPE_COLOR,
+            effectColor2.getType());
+        assertEquals("Effect Color", EffectColor.GRAY, effectColor2.getColor());
+
+        final EffectColor effectColor3 = mVideoEditorHelper.createEffectItem(
+            mediaVideoItem1, "effect3", 3000, 1000, EffectColor.TYPE_COLOR,
+            EffectColor.GREEN);
+        mediaVideoItem1.addEffect(effectColor3);
+
+        assertEquals("Associated Media Item", mediaVideoItem1,
+            effectColor3.getMediaItem());
+        assertTrue("Effect Id", effectColor3.getId().equals("effect3"));
+        assertEquals("Effect StartTime", 3000, effectColor3.getStartTime());
+        assertEquals("Effect EndTime", 1000, effectColor3.getDuration());
+        assertEquals("Effect Type", EffectColor.TYPE_COLOR,
+            effectColor3.getType());
+        assertEquals("Effect Color", EffectColor.GREEN, effectColor3.getColor());
+
+        final EffectColor effectColor4 = mVideoEditorHelper.createEffectItem(
+            mediaVideoItem1, "effect4", 4000, 1000, EffectColor.TYPE_GRADIENT,
+            EffectColor.PINK);
+        mediaVideoItem1.addEffect(effectColor4);
+
+        assertEquals("Associated Media Item", mediaVideoItem1,
+            effectColor4.getMediaItem());
+        assertTrue("Effect Id", effectColor4.getId().equals("effect4"));
+        assertEquals("Effect StartTime", 4000, effectColor4.getStartTime());
+        assertEquals("Effect EndTime", 1000, effectColor4.getDuration());
+        assertEquals("Effect Type", EffectColor.TYPE_GRADIENT,
+            effectColor4.getType());
+        assertEquals("Effect Color", EffectColor.PINK, effectColor4.getColor());
+
+        final EffectColor effectColor5 = mVideoEditorHelper.createEffectItem(
+            mediaVideoItem1, "effect5", 5000, 1000,
+            EffectColor.TYPE_GRADIENT, EffectColor.GRAY);
+        mediaVideoItem1.addEffect(effectColor5);
+
+        assertEquals("Associated Media Item", mediaVideoItem1,
+            effectColor5.getMediaItem());
+        assertTrue("Effect Id", effectColor5.getId().equals("effect5"));
+        assertEquals("Effect StartTime", 5000, effectColor5.getStartTime());
+        assertEquals("Effect EndTime", 1000, effectColor5.getDuration());
+        assertEquals("Effect Type", EffectColor.TYPE_GRADIENT,
+            effectColor5.getType());
+        assertEquals("Effect Color", EffectColor.GRAY, effectColor5.getColor());
+
+        final EffectColor effectColor6 = mVideoEditorHelper.createEffectItem(
+            mediaVideoItem1, "effect6", 6000, 1000,
+            EffectColor.TYPE_GRADIENT, EffectColor.GREEN);
+        mediaVideoItem1.addEffect(effectColor6);
+
+        assertEquals("Associated Media Item", mediaVideoItem1,
+            effectColor6.getMediaItem());
+        assertTrue("Effect Id", effectColor6.getId().equals("effect6"));
+        assertEquals("Effect StartTime", 6000, effectColor6.getStartTime());
+        assertEquals("Effect EndTime", 1000, effectColor6.getDuration());
+        assertEquals("Effect Type",
+            EffectColor.TYPE_GRADIENT, effectColor6.getType());
+        assertEquals("Effect Color",
+            EffectColor.GREEN, effectColor6.getColor());
+
+        final EffectColor effectColor7 = mVideoEditorHelper.createEffectItem(
+            mediaVideoItem1, "effect7", 7000, 1000,
+            EffectColor.TYPE_FIFTIES, 0);
+        mediaVideoItem1.addEffect(effectColor7);
+
+        assertEquals("Associated Media Item", mediaVideoItem1,
+            effectColor7.getMediaItem());
+        assertTrue("Effect Id", effectColor7.getId().equals("effect7"));
+        assertEquals("Effect StartTime", 7000, effectColor7.getStartTime());
+        assertEquals("Effect EndTime", 1000, effectColor7.getDuration());
+        assertEquals("Effect Type", EffectColor.TYPE_FIFTIES,
+            effectColor7.getType());
+        assertEquals("Effect Color", -1, effectColor7.getColor());
+
+        final EffectColor effectColor8 = mVideoEditorHelper.createEffectItem(
+            mediaVideoItem1, "effect8", 8000, 1000, EffectColor.TYPE_SEPIA, 0);
+        mediaVideoItem1.addEffect(effectColor8);
+
+        assertEquals("Associated Media Item", mediaVideoItem1,
+            effectColor8.getMediaItem());
+        assertTrue("Effect Id", effectColor8.getId().equals("effect8"));
+        assertEquals("Effect StartTime", 8000, effectColor8.getStartTime());
+        assertEquals("Effect EndTime", 1000, effectColor8.getDuration());
+        assertEquals("Effect Type", EffectColor.TYPE_SEPIA,
+            effectColor8.getType());
+        assertEquals("Effect Color", -1, effectColor8.getColor());
+
+        final EffectColor effectColor9 = mVideoEditorHelper.createEffectItem(
+            mediaVideoItem1, "effect9", 9000, 1000,
+            EffectColor.TYPE_NEGATIVE, 0);
+        mediaVideoItem1.addEffect(effectColor9);
+
+        assertEquals("Associated Media Item", mediaVideoItem1,
+            effectColor9.getMediaItem());
+        assertTrue("Effect Id", effectColor9.getId().equals("effect9"));
+        assertEquals("Effect StartTime", 9000, effectColor9.getStartTime());
+        assertEquals("Effect EndTime", 1000, effectColor9.getDuration());
+        assertEquals("Effect Type", EffectColor.TYPE_NEGATIVE,
+            effectColor9.getType());
+        assertEquals("Effect Color", -1, effectColor9.getColor());
+        try {
+            mVideoEditorHelper.createEffectItem(mediaVideoItem1, "effect9",
+                9000, 1000, EffectColor.TYPE_COLOR - 1, 0);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Effect type Invalid", flagForException);
+        flagForException = false;
+        try {
+            mVideoEditorHelper.createEffectItem(mediaVideoItem1, "effect9",
+                9000, 1000, EffectColor.TYPE_FIFTIES + 1, 0);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Effect type Invalid", flagForException);
+        try {
+            mVideoEditorHelper.createEffectItem(mediaVideoItem1, "effect10",
+                10000, 1000, EffectColor.TYPE_FIFTIES +
+                EffectColor.TYPE_GRADIENT, 0);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Effect type Invalid", flagForException);
+    }
+
+    /**
+     * To test Effect Color : Set duration and Get Duration
+     */
+    // TODO : remove TC_API_026
+    @LargeTest
+    public void testEffectSetgetDuration() throws Exception {
+        final String videoItemFileName = INPUT_FILE_PATH +
+            "MPEG4_SP_640x480_30fps_512Kbps_0_27.mp4";
+        final int videoItemRenderingMode =MediaItem.RENDERING_MODE_BLACK_BORDER;
+        boolean flagForException = false;
+        final MediaVideoItem mediaVideoItem1 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "mediaVideoItem1",
+            videoItemFileName, videoItemRenderingMode);
+        mVideoEditor.addMediaItem(mediaVideoItem1);
+
+        final EffectColor effectColor1 = mVideoEditorHelper.createEffectItem(
+            mediaVideoItem1, "effect1", 1000, 2000,
+            EffectColor.TYPE_COLOR, EffectColor.PINK);
+        mediaVideoItem1.addEffect(effectColor1);
+
+        effectColor1.setDuration(5000);
+        assertEquals("Updated Effect Duration", 5000,
+            effectColor1.getDuration());
+        try {
+            effectColor1.setDuration(mediaVideoItem1.getDuration() + 1000);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Effect Color duration > mediaVideoItemDuration",
+            flagForException);
+        assertEquals("Effect Duration", 5000, effectColor1.getDuration());
+        flagForException = false;
+        try {
+            effectColor1.setDuration(-1);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Effect Color duration = -1", flagForException);
+    }
+
+    /**
+     * To test Effect Color : UNDEFINED color param value
+     */
+    // TODO : remove TC_API_027
+    @LargeTest
+    public void testEffectUndefinedColorParam() throws Exception {
+        final String videoItemFileName = INPUT_FILE_PATH +
+            "MPEG4_SP_640x480_30fps_512Kbps_0_27.mp4";
+        final int videoItemRenderingMode =MediaItem.RENDERING_MODE_BLACK_BORDER;
+        boolean flagForException = false;
+        final MediaVideoItem mediaVideoItem1 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "mediaVideoItem1",
+            videoItemFileName, videoItemRenderingMode);
+        mVideoEditor.addMediaItem(mediaVideoItem1);
+        try{
+        mVideoEditorHelper.createEffectItem(mediaVideoItem1, "effect1", 1000,
+            2000, EffectColor.TYPE_COLOR, 0xabcdabcd);
+        }catch (IllegalArgumentException e){
+            flagForException = true;
+        }
+        assertTrue("Invalid Effect added",flagForException);
+    }
+
+    /**
+     * To test Effect Color : with Invalid StartTime and Duration
+     */
+    // TODO : remove TC_API_028
+    @LargeTest
+    public void testEffectInvalidStartTimeAndDuration() throws Exception {
+        final String videoItemFileName = INPUT_FILE_PATH +
+            "H264_BP_640x480_15fps_1200Kbps_AACLC_48KHz_32kbps_m_1_17.3gp";
+        final int videoItemRenderingMode =MediaItem.RENDERING_MODE_BLACK_BORDER;
+        boolean flagForException = false;
+        final MediaVideoItem mediaVideoItem1 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "mediaVideoItem1",
+            videoItemFileName, videoItemRenderingMode);
+        mVideoEditor.addMediaItem(mediaVideoItem1);
+
+        try {
+            mVideoEditorHelper.createEffectItem(mediaVideoItem1, "effect1",
+                400000000, 2000, EffectColor.TYPE_COLOR, EffectColor.GREEN);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Effect with invalid StartTime", flagForException);
+
+        flagForException = false;
+        try {
+            mVideoEditorHelper.createEffectItem(mediaVideoItem1, "effect1", -1,
+                2000, EffectColor.TYPE_COLOR, EffectColor.GREEN);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Effect with invalid StartTime", flagForException);
+
+        flagForException = false;
+        try {
+            mVideoEditorHelper.createEffectItem(mediaVideoItem1, "effect1",
+                2000, -1, EffectColor.TYPE_COLOR, EffectColor.GREEN);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Effect with invalid Duration", flagForException);
+    }
+
+
+    /** Test cases 29, 30, 31, 32 and 33 are removed */
+
+
+    /**
+     * To test Effect : with NULL Media Item
+     */
+    // TODO : remove TC_API_034
+    @LargeTest
+    public void testEffectNullMediaItem() throws Exception {
+        boolean flagForException = false;
+        try {
+            mVideoEditorHelper.createEffectItem(null, "effect1", 1000, 4000,
+                EffectColor.TYPE_COLOR, EffectColor.GREEN);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Effect with null MediaItem", flagForException);
+    }
+
+    /**
+     * To test Effect : KenBurn Effect
+     */
+    // TODO : remove TC_API_035
+    @LargeTest
+    public void testEffectKenBurn() throws Exception {
+        final String imageItemFileName = INPUT_FILE_PATH + "IMG_640x480.jpg";
+        final int imageItemRenderingMode =MediaItem.RENDERING_MODE_BLACK_BORDER;
+        final MediaImageItem mediaImageItem =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "mediaImageItem1",
+            imageItemFileName, 5000, imageItemRenderingMode);
+        mVideoEditor.addMediaItem(mediaImageItem);
+
+        final Rect startRect = new Rect((mediaImageItem.getHeight() / 3),
+            (mediaImageItem.getWidth() / 3), (mediaImageItem.getHeight() / 2),
+            (mediaImageItem.getWidth() / 2));
+        final Rect endRect = new Rect(0, 0, mediaImageItem.getWidth(),
+            mediaImageItem.getHeight());
+
+        final EffectKenBurns kbEffectOnMediaItem = new EffectKenBurns(
+            mediaImageItem, "KBOnM2", startRect, endRect, 500, 3000);
+
+        assertNotNull("EffectKenBurns", kbEffectOnMediaItem);
+        mediaImageItem.addEffect(kbEffectOnMediaItem);
+        assertEquals("KenBurn Start Rect", startRect,
+            kbEffectOnMediaItem.getStartRect());
+        assertEquals("KenBurn End Rect", endRect,
+            kbEffectOnMediaItem.getEndRect());
+    }
+
+    /**
+     * To test KenBurnEffect : Set StartRect and EndRect
+     */
+
+    // TODO : remove TC_API_036
+    @LargeTest
+    public void testEffectKenBurnSet() throws Exception {
+        final String imageItemFileName = INPUT_FILE_PATH + "IMG_640x480.jpg";
+        final int imageItemRenderingMode =MediaItem.RENDERING_MODE_BLACK_BORDER;
+        boolean flagForException = false;
+        final MediaImageItem mediaImageItem =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "mediaImageItem1",
+            imageItemFileName, 5000, imageItemRenderingMode);
+        mVideoEditor.addMediaItem(mediaImageItem);
+
+        final Rect startRect = new Rect((mediaImageItem.getHeight() / 3),
+            (mediaImageItem.getWidth() / 3), (mediaImageItem.getHeight() / 2),
+            (mediaImageItem.getWidth() / 2));
+        final Rect endRect = new Rect(0, 0, mediaImageItem.getWidth(),
+            mediaImageItem.getHeight());
+
+        EffectKenBurns kbEffectOnMediaItem=null;
+        kbEffectOnMediaItem = new EffectKenBurns(mediaImageItem, "KBOnM2",
+            startRect, endRect, 500, 3000);
+
+        assertNotNull("EffectKenBurns", kbEffectOnMediaItem);
+        mediaImageItem.addEffect(kbEffectOnMediaItem);
+        assertEquals("KenBurn Start Rect", startRect,
+            kbEffectOnMediaItem.getStartRect());
+        assertEquals("KenBurn End Rect", endRect,
+            kbEffectOnMediaItem.getEndRect());
+
+        final Rect startRect1 = new Rect((mediaImageItem.getHeight() / 5),
+            (mediaImageItem.getWidth() / 5), (mediaImageItem.getHeight() / 4),
+            (mediaImageItem.getWidth() / 4));
+        final Rect endRect1 = new Rect(10, 10, mediaImageItem.getWidth() / 4,
+            mediaImageItem.getHeight() / 4);
+
+        kbEffectOnMediaItem.setStartRect(startRect1);
+        kbEffectOnMediaItem.setEndRect(endRect1);
+        assertEquals("KenBurn Start Rect", startRect1,
+            kbEffectOnMediaItem.getStartRect());
+        assertEquals("KenBurn End Rect", endRect1,
+            kbEffectOnMediaItem.getEndRect());
+
+        final Rect zeroRect = new Rect(0, 0, 0, 0);
+        try {
+            kbEffectOnMediaItem.setStartRect(zeroRect);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Invalid Start Rect", flagForException);
+
+        flagForException = false;
+        try {
+            kbEffectOnMediaItem.setEndRect(zeroRect);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Invalid End Rect", flagForException);
+    }
+
+    /**
+     * To test Transition : Fade To Black with all behavior
+     * SPEED_UP/SPEED_DOWN/LINEAR/MIDDLE_SLOW/MIDDLE_FAST
+     */
+
+    // TODO : remove TC_API_037
+    @LargeTest
+    public void testTransitionFadeBlack() throws Exception {
+
+        final String videoItemFilename1 = INPUT_FILE_PATH +
+            "H264_BP_640x480_30fps_256kbps_1_17.mp4";
+        final String videoItemFilename2 = INPUT_FILE_PATH +
+            "H263_profile0_176x144_15fps_128kbps_1_35.3gp";
+        final String imageItemFilename1 = INPUT_FILE_PATH + "IMG_1600x1200.jpg";
+        final String videoItemFilename3 = INPUT_FILE_PATH +
+            "H264_BP_640x480_30fps_192kbps_1_5.mp4";
+        final String videoItemFilename4 = INPUT_FILE_PATH +
+            "MPEG4_SP_640x480_15fps_256kbps_0_30.mp4";
+        final String videoItemFilename5 = INPUT_FILE_PATH +
+            "H263_profile0_176x144_10fps_96kbps_0_25.3gp";
+        boolean flagForException = false;
+
+        final MediaVideoItem mediaVideoItem1 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
+            videoItemFilename1, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mediaVideoItem1.setExtractBoundaries(0, 15000);
+        mVideoEditor.addMediaItem(mediaVideoItem1);
+
+        final MediaVideoItem mediaVideoItem2 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m2",
+            videoItemFilename2, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mediaVideoItem2.setExtractBoundaries(0, 15000);
+        mVideoEditor.addMediaItem(mediaVideoItem2);
+
+        final TransitionFadeBlack transition1And2 = mVideoEditorHelper
+            .createTFadeBlack("transition1And2", mediaVideoItem1,
+            mediaVideoItem2, 3000, Transition.BEHAVIOR_SPEED_UP);
+        mVideoEditor.addTransition(transition1And2);
+
+        assertTrue("Transition ID",
+            transition1And2.getId().equals("transition1And2"));
+        assertEquals("Transtion After Media item",
+            mediaVideoItem1, transition1And2.getAfterMediaItem());
+        assertEquals("Transtion Before Media item", mediaVideoItem2,
+            transition1And2.getBeforeMediaItem());
+        assertEquals("Transtion Duration", 3000, transition1And2.getDuration());
+        assertEquals("Transtion Behavior", Transition.BEHAVIOR_SPEED_UP,
+            transition1And2.getBehavior());
+
+        final MediaImageItem mediaImageItem3 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m3",
+                imageItemFilename1, 15000, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mVideoEditor.addMediaItem(mediaImageItem3);
+
+        final TransitionFadeBlack transition2And3 =
+            mVideoEditorHelper.createTFadeBlack("transition2And3", mediaVideoItem2,
+                mediaImageItem3, 1000, Transition.BEHAVIOR_SPEED_DOWN);
+        mVideoEditor.addTransition(transition2And3);
+
+        assertTrue("Transition ID",
+            transition2And3.getId().equals("transition2And3"));
+        assertEquals("Transtion After Media item", mediaVideoItem2,
+            transition2And3.getAfterMediaItem());
+        assertEquals("Transtion Before Media item", mediaImageItem3,
+            transition2And3.getBeforeMediaItem());
+        assertEquals("Transtion Duration", 1000, transition2And3.getDuration());
+        assertEquals("Transtion Behavior", Transition.BEHAVIOR_SPEED_DOWN,
+            transition2And3.getBehavior());
+
+        final MediaVideoItem mediaVideoItem4 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m4",
+                videoItemFilename3, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mediaVideoItem4.setExtractBoundaries(0, 20000);
+        mVideoEditor.addMediaItem(mediaVideoItem4);
+
+        final TransitionFadeBlack transition3And4 =
+            mVideoEditorHelper.createTFadeBlack("transition3And4", mediaImageItem3,
+                mediaVideoItem4, 5000, Transition.BEHAVIOR_LINEAR);
+        mVideoEditor.addTransition(transition3And4);
+
+        assertTrue("Transition ID",
+            transition3And4.getId().equals("transition3And4"));
+        assertEquals("Transtion After Media item", mediaImageItem3,
+            transition3And4.getAfterMediaItem());
+        assertEquals("Transtion Before Media item", mediaVideoItem4,
+            transition3And4.getBeforeMediaItem());
+        assertEquals("Transtion Duration", 5000, transition3And4.getDuration());
+        assertEquals("Transtion Behavior", Transition.BEHAVIOR_LINEAR,
+            transition3And4.getBehavior());
+
+        final MediaVideoItem mediaVideoItem5 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m5",
+                videoItemFilename4, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mVideoEditor.addMediaItem(mediaVideoItem5);
+
+        final TransitionFadeBlack transition4And5 =
+            mVideoEditorHelper.createTFadeBlack("transition4And5", mediaVideoItem4,
+                mediaVideoItem5, 8000, Transition.BEHAVIOR_MIDDLE_FAST);
+        mVideoEditor.addTransition(transition4And5);
+
+        assertTrue("Transition ID",
+            transition4And5.getId().equals("transition4And5"));
+        assertEquals("Transtion After Media item", mediaVideoItem4,
+            transition4And5.getAfterMediaItem());
+        assertEquals("Transtion Before Media item", mediaVideoItem5,
+            transition4And5.getBeforeMediaItem());
+        assertEquals("Transtion Duration", 8000, transition4And5.getDuration());
+        assertEquals("Transtion Behavior", Transition.BEHAVIOR_MIDDLE_FAST,
+            transition4And5.getBehavior());
+
+        final MediaVideoItem mediaVideoItem6 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m6",
+                videoItemFilename5, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mediaVideoItem6.setExtractBoundaries(0, 20000);
+        mVideoEditor.addMediaItem(mediaVideoItem6);
+
+        final TransitionFadeBlack transition5And6 =
+            mVideoEditorHelper.createTFadeBlack("transition5And6", mediaVideoItem5,
+                mediaVideoItem6, 2000, Transition.BEHAVIOR_MIDDLE_SLOW);
+        mVideoEditor.addTransition(transition5And6);
+
+        assertTrue("Transition ID",
+            transition5And6.getId().equals("transition5And6"));
+        assertEquals("Transtion After Media item", mediaVideoItem5,
+            transition5And6.getAfterMediaItem());
+        assertEquals("Transtion Before Media item", mediaVideoItem6,
+            transition5And6.getBeforeMediaItem());
+        assertEquals("Transtion Duration", 2000, transition5And6.getDuration());
+        assertEquals("Transtion Behavior", Transition.BEHAVIOR_MIDDLE_SLOW,
+            transition5And6.getBehavior());
+        flagForException = false;
+        try {
+            mVideoEditorHelper.createTFadeBlack("transitiond6", mediaVideoItem5,
+                mediaVideoItem6, 2000, Transition.BEHAVIOR_SPEED_UP - 1);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Transition FadeBlack with Invalid behavior", flagForException);
+        flagForException = false;
+        try {
+            mVideoEditorHelper.createTFadeBlack("transitiond6", mediaVideoItem5,
+                mediaVideoItem6, 2000, Transition.BEHAVIOR_MIDDLE_FAST + 1);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Transition FadeBlack with Invalid behavior", flagForException);
+    }
+
+    /**
+     * To test Transition : CrossFade with all behavior
+     * SPEED_UP/SPEED_DOWN/LINEAR/MIDDLE_SLOW/MIDDLE_FAST
+     */
+
+    // TODO : remove TC_API_038
+    @LargeTest
+    public void testTransitionCrossFade() throws Exception {
+
+        final String videoItemFilename1 = INPUT_FILE_PATH +
+            "H264_BP_640x480_30fps_256kbps_1_17.mp4";
+        final String videoItemFilename2 = INPUT_FILE_PATH +
+            "H263_profile0_176x144_15fps_128kbps_1_35.3gp";
+        final String imageItemFilename1 = INPUT_FILE_PATH + "IMG_1600x1200.jpg";
+        final String videoItemFilename3 = INPUT_FILE_PATH +
+            "H264_BP_640x480_30fps_192kbps_1_5.mp4";
+        final String videoItemFilename4 = INPUT_FILE_PATH +
+            "MPEG4_SP_640x480_15fps_256kbps_0_30.mp4";
+        final String videoItemFilename5 = INPUT_FILE_PATH +
+            "H263_profile0_176x144_10fps_96kbps_0_25.3gp";
+        boolean flagForException = false;
+        final MediaVideoItem mediaVideoItem1 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
+                videoItemFilename1, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mediaVideoItem1.setExtractBoundaries(0, 15000);
+        mVideoEditor.addMediaItem(mediaVideoItem1);
+
+        final MediaVideoItem mediaVideoItem2 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m2",
+                videoItemFilename2, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mediaVideoItem2.setExtractBoundaries(0, 15000);
+        mVideoEditor.addMediaItem(mediaVideoItem2);
+
+        final TransitionCrossfade transition1And2 =
+            mVideoEditorHelper.createTCrossFade("transition1And2", mediaVideoItem1,
+                mediaVideoItem2, 3000, Transition.BEHAVIOR_SPEED_UP);
+        mVideoEditor.addTransition(transition1And2);
+
+        assertTrue("Transition ID",
+            transition1And2.getId().equals("transition1And2"));
+        assertEquals("Transtion After Media item", mediaVideoItem1,
+            transition1And2.getAfterMediaItem());
+        assertEquals("Transtion Before Media item", mediaVideoItem2,
+            transition1And2.getBeforeMediaItem());
+        assertEquals("Transtion Duration", 3000, transition1And2.getDuration());
+        assertEquals("Transtion Behavior", Transition.BEHAVIOR_SPEED_UP,
+            transition1And2.getBehavior());
+
+        final MediaImageItem mediaImageItem3 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m3",
+                imageItemFilename1, 15000, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mVideoEditor.addMediaItem(mediaImageItem3);
+
+        final TransitionCrossfade transition2And3 =
+            mVideoEditorHelper.createTCrossFade("transition2And3", mediaVideoItem2,
+                mediaImageItem3, 1000, Transition.BEHAVIOR_SPEED_DOWN);
+        mVideoEditor.addTransition(transition2And3);
+
+        assertTrue("Transition ID",
+            transition2And3.getId().equals("transition2And3"));
+        assertEquals("Transtion After Media item", mediaVideoItem2,
+            transition2And3.getAfterMediaItem());
+        assertEquals("Transtion Before Media item", mediaImageItem3,
+            transition2And3.getBeforeMediaItem());
+        assertEquals("Transtion Duration", 1000, transition2And3.getDuration());
+        assertEquals("Transtion Behavior", Transition.BEHAVIOR_SPEED_DOWN,
+            transition2And3.getBehavior());
+
+        final MediaVideoItem mediaVideoItem4 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m4",
+                videoItemFilename3, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mediaVideoItem4.setExtractBoundaries(0, 18000);
+        mVideoEditor.addMediaItem(mediaVideoItem4);
+
+        final TransitionCrossfade transition3And4 =
+            mVideoEditorHelper.createTCrossFade("transition3And4", mediaImageItem3,
+                mediaVideoItem4, 5000, Transition.BEHAVIOR_LINEAR);
+        mVideoEditor.addTransition(transition3And4);
+
+        assertTrue("Transition ID",
+            transition3And4.getId().equals("transition3And4"));
+        assertEquals("Transtion After Media item", mediaImageItem3,
+            transition3And4.getAfterMediaItem());
+        assertEquals("Transtion Before Media item", mediaVideoItem4,
+            transition3And4.getBeforeMediaItem());
+        assertEquals("Transtion Duration", 5000, transition3And4.getDuration());
+        assertEquals("Transtion Behavior", Transition.BEHAVIOR_LINEAR,
+            transition3And4.getBehavior());
+
+        final MediaVideoItem mediaVideoItem5 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m5",
+                videoItemFilename4, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mVideoEditor.addMediaItem(mediaVideoItem5);
+
+        final TransitionCrossfade transition4And5 =
+            mVideoEditorHelper.createTCrossFade("transition4And5", mediaVideoItem4,
+                mediaVideoItem5, 8000, Transition.BEHAVIOR_MIDDLE_FAST);
+        mVideoEditor.addTransition(transition4And5);
+
+        assertTrue("Transition ID",
+            transition4And5.getId().equals("transition4And5"));
+        assertEquals("Transtion After Media item", mediaVideoItem4,
+            transition4And5.getAfterMediaItem());
+        assertEquals("Transtion Before Media item", mediaVideoItem5,
+            transition4And5.getBeforeMediaItem());
+        assertEquals("Transtion Duration", 8000, transition4And5.getDuration());
+        assertEquals("Transtion Behavior", Transition.BEHAVIOR_MIDDLE_FAST,
+            transition4And5.getBehavior());
+
+        final MediaVideoItem mediaVideoItem6 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m6",
+                videoItemFilename5, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mediaVideoItem6.setExtractBoundaries(0, 20000);
+        mVideoEditor.addMediaItem(mediaVideoItem6);
+
+        final TransitionCrossfade transition5And6 =
+            mVideoEditorHelper.createTCrossFade("transition5And6", mediaVideoItem5,
+                mediaVideoItem6, 2000, Transition.BEHAVIOR_MIDDLE_SLOW);
+        mVideoEditor.addTransition(transition5And6);
+
+        assertTrue("Transition ID",
+            transition5And6.getId().equals("transition5And6"));
+        assertEquals("Transtion After Media item", mediaVideoItem5,
+            transition5And6.getAfterMediaItem());
+        assertEquals("Transtion Before Media item", mediaVideoItem6,
+            transition5And6.getBeforeMediaItem());
+        assertEquals("Transtion Duration", 2000, transition5And6.getDuration());
+        assertEquals("Transtion Behavior", Transition.BEHAVIOR_MIDDLE_SLOW,
+            transition5And6.getBehavior());
+
+        flagForException = false;
+        try {
+            mVideoEditorHelper.createTCrossFade("transitiond6", mediaVideoItem5,
+                mediaVideoItem6, 2000, Transition.BEHAVIOR_SPEED_UP - 1);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Transition FadeBlack with Invalid behavior", flagForException);
+        flagForException = false;
+        try {
+            mVideoEditorHelper.createTCrossFade("transitiond6", mediaVideoItem5,
+                mediaVideoItem6, 2000, Transition.BEHAVIOR_MIDDLE_FAST + 1);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Transition FadeBlack with Invalid behavior", flagForException);
+    }
+
+    /**
+     * To test Transition : Sliding with all behavior
+     * SPEED_UP/SPEED_DOWN/LINEAR/MIDDLE_SLOW/MIDDLE_FAST and Direction =
+     * DIRECTION_RIGHT_OUT_LEFT_IN
+     * ,DIRECTION_LEFT_OUT_RIGHT_IN,DIRECTION_TOP_OUT_BOTTOM_IN
+     * ,DIRECTION_BOTTOM_OUT_TOP_IN
+     */
+
+    // TODO : remove TC_API_039
+    @LargeTest
+    public void testTransitionSliding() throws Exception {
+        final String videoItemFilename1 = INPUT_FILE_PATH +
+            "H264_BP_640x480_30fps_256kbps_1_17.mp4";
+        final String videoItemFilename2 = INPUT_FILE_PATH +
+            "H263_profile0_176x144_15fps_128kbps_1_35.3gp";
+        final String imageItemFilename1 = INPUT_FILE_PATH +
+            "IMG_1600x1200.jpg";
+        final String videoItemFilename3 = INPUT_FILE_PATH +
+            "H264_BP_640x480_30fps_192kbps_1_5.mp4";
+        final String videoItemFilename4 = INPUT_FILE_PATH +
+            "MPEG4_SP_640x480_15fps_256kbps_0_30.mp4";
+        final String videoItemFilename5 = INPUT_FILE_PATH +
+            "H263_profile0_176x144_10fps_96kbps_0_25.3gp";
+        boolean flagForException = false;
+
+        final MediaVideoItem mediaVideoItem1 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
+                videoItemFilename1, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mediaVideoItem1.setExtractBoundaries(0, 15000);
+        mVideoEditor.addMediaItem(mediaVideoItem1);
+
+        final MediaVideoItem mediaVideoItem2 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m2",
+                videoItemFilename2, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mediaVideoItem2.setExtractBoundaries(0, 15000);
+        mVideoEditor.addMediaItem(mediaVideoItem2);
+
+        final TransitionSliding transition1And2 =
+            mVideoEditorHelper.createTSliding("transition1And2", mediaVideoItem1,
+                mediaVideoItem2, 3000, Transition.BEHAVIOR_SPEED_UP,
+                TransitionSliding.DIRECTION_RIGHT_OUT_LEFT_IN);
+        mVideoEditor.addTransition(transition1And2);
+
+        assertTrue("Transition ID",
+            transition1And2.getId().equals("transition1And2"));
+        assertEquals("Transtion After Media item", mediaVideoItem1,
+            transition1And2.getAfterMediaItem());
+        assertEquals("Transtion Before Media item", mediaVideoItem2,
+            transition1And2.getBeforeMediaItem());
+        assertEquals("Transtion Duration", 3000, transition1And2.getDuration());
+        assertEquals("Transtion Behavior", Transition.BEHAVIOR_SPEED_UP,
+            transition1And2.getBehavior());
+        assertEquals("Transition Sliding",
+            TransitionSliding.DIRECTION_RIGHT_OUT_LEFT_IN,
+            transition1And2.getDirection());
+
+        final MediaImageItem mediaImageItem3 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m3",
+                imageItemFilename1, 15000, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mVideoEditor.addMediaItem(mediaImageItem3);
+
+        final TransitionSliding transition2And3 =
+            mVideoEditorHelper.createTSliding("transition2And3",
+                mediaVideoItem2, mediaImageItem3, 1000,
+                Transition.BEHAVIOR_SPEED_DOWN,
+                TransitionSliding.DIRECTION_LEFT_OUT_RIGHT_IN);
+        mVideoEditor.addTransition(transition2And3);
+
+        assertTrue("Transition ID",
+            transition2And3.getId().equals("transition2And3"));
+        assertEquals("Transtion After Media item", mediaVideoItem2,
+            transition2And3.getAfterMediaItem());
+        assertEquals("Transtion Before Media item", mediaImageItem3,
+            transition2And3.getBeforeMediaItem());
+        assertEquals("Transtion Duration", 1000, transition2And3.getDuration());
+        assertEquals("Transtion Behavior", Transition.BEHAVIOR_SPEED_DOWN,
+            transition2And3.getBehavior());
+        assertEquals("Transition Sliding",
+            TransitionSliding.DIRECTION_LEFT_OUT_RIGHT_IN,
+            transition2And3.getDirection());
+
+        final MediaVideoItem mediaVideoItem4 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m4",
+                videoItemFilename3, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mediaVideoItem4.setExtractBoundaries(0, 18000);
+        mVideoEditor.addMediaItem(mediaVideoItem4);
+
+        final TransitionSliding transition3And4 =
+            mVideoEditorHelper.createTSliding("transition3And4", mediaImageItem3,
+                mediaVideoItem4, 5000, Transition.BEHAVIOR_LINEAR,
+                TransitionSliding.DIRECTION_TOP_OUT_BOTTOM_IN);
+        mVideoEditor.addTransition(transition3And4);
+
+        assertTrue("Transition ID",
+            transition3And4.getId().equals("transition3And4"));
+        assertEquals("Transtion After Media item", mediaImageItem3,
+            transition3And4.getAfterMediaItem());
+        assertEquals("Transtion Before Media item", mediaVideoItem4,
+            transition3And4.getBeforeMediaItem());
+        assertEquals("Transtion Duration", 5000, transition3And4.getDuration());
+        assertEquals("Transtion Behavior", Transition.BEHAVIOR_LINEAR,
+            transition3And4.getBehavior());
+        assertEquals("Transition Sliding",
+            TransitionSliding.DIRECTION_TOP_OUT_BOTTOM_IN,
+            transition3And4.getDirection());
+
+        final MediaVideoItem mediaVideoItem5 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m5",
+                videoItemFilename4, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mVideoEditor.addMediaItem(mediaVideoItem5);
+
+        final TransitionSliding transition4And5 =
+            mVideoEditorHelper.createTSliding("transition4And5", mediaVideoItem4,
+                mediaVideoItem5, 8000, Transition.BEHAVIOR_MIDDLE_FAST,
+                TransitionSliding.DIRECTION_BOTTOM_OUT_TOP_IN);
+        mVideoEditor.addTransition(transition4And5);
+
+        assertTrue("Transition ID",
+            transition4And5.getId().equals("transition4And5"));
+        assertEquals("Transtion After Media item", mediaVideoItem4,
+            transition4And5.getAfterMediaItem());
+        assertEquals("Transtion Before Media item", mediaVideoItem5,
+            transition4And5.getBeforeMediaItem());
+        assertEquals("Transtion Duration", 8000, transition4And5.getDuration());
+        assertEquals("Transtion Behavior", Transition.BEHAVIOR_MIDDLE_FAST,
+            transition4And5.getBehavior());
+        assertEquals("Transition Sliding",
+            TransitionSliding.DIRECTION_BOTTOM_OUT_TOP_IN,
+            transition4And5.getDirection());
+
+        final MediaVideoItem mediaVideoItem6 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m6",
+                videoItemFilename5, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mediaVideoItem6.setExtractBoundaries(0, 20000);
+        mVideoEditor.addMediaItem(mediaVideoItem6);
+
+        final TransitionSliding transition5And6 =
+            mVideoEditorHelper.createTSliding("transition5And6", mediaVideoItem5,
+                mediaVideoItem6, 2000, Transition.BEHAVIOR_MIDDLE_SLOW,
+                TransitionSliding.DIRECTION_RIGHT_OUT_LEFT_IN);
+        mVideoEditor.addTransition(transition5And6);
+
+        assertTrue("Transition ID",
+            transition5And6.getId().equals("transition5And6"));
+        assertEquals("Transtion After Media item", mediaVideoItem5,
+            transition5And6.getAfterMediaItem());
+        assertEquals("Transtion Before Media item", mediaVideoItem6,
+            transition5And6.getBeforeMediaItem());
+        assertEquals("Transtion Duration", 2000, transition5And6.getDuration());
+        assertEquals("Transtion Behavior", Transition.BEHAVIOR_MIDDLE_SLOW,
+            transition5And6.getBehavior());
+        assertEquals("Transition Sliding",
+            TransitionSliding.DIRECTION_RIGHT_OUT_LEFT_IN,
+            transition5And6.getDirection());
+
+        flagForException = false;
+        try {
+            mVideoEditorHelper.createTSliding("transitiond6", mediaVideoItem5,
+                mediaVideoItem6, 2000, Transition.BEHAVIOR_MIDDLE_SLOW,
+                TransitionSliding.DIRECTION_RIGHT_OUT_LEFT_IN - 1);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Transition Sliding with Invalid Direction", flagForException);
+        flagForException = false;
+        try {
+            mVideoEditorHelper.createTSliding("transitiond6", mediaVideoItem5,
+                mediaVideoItem6, 2000, Transition.BEHAVIOR_MIDDLE_FAST + 1,
+                TransitionSliding.DIRECTION_BOTTOM_OUT_TOP_IN + 1);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Transition Sliding with Invalid behavior", flagForException);
+        flagForException = false;
+        try {
+            mVideoEditorHelper.createTSliding("transitiond6", mediaVideoItem5,
+                mediaVideoItem6, 2000, Transition.BEHAVIOR_SPEED_UP - 1,
+                TransitionSliding.DIRECTION_RIGHT_OUT_LEFT_IN);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Transition Sliding with Invalid behavior", flagForException);
+        flagForException = false;
+        try {
+            mVideoEditorHelper.createTSliding("transitiond6", mediaVideoItem5,
+                mediaVideoItem6, 2000, Transition.BEHAVIOR_MIDDLE_FAST + 1,
+                TransitionSliding.DIRECTION_RIGHT_OUT_LEFT_IN);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Transition Sliding with Invalid behavior", flagForException);
+    }
+
+    /**
+     * To test Transition : Alpha with all behavior
+     * SPEED_UP/SPEED_DOWN/LINEAR/MIDDLE_SLOW/MIDDLE_FAST
+     */
+
+    // TODO : remove TC_API_040
+    @LargeTest
+    public void testTransitionAlpha() throws Exception {
+
+        final String videoItemFilename1 = INPUT_FILE_PATH +
+            "H264_BP_640x480_30fps_256kbps_1_17.mp4";
+        final String videoItemFilename2 = INPUT_FILE_PATH +
+            "H263_profile0_176x144_15fps_128kbps_1_35.3gp";
+        final String imageItemFilename1 = INPUT_FILE_PATH +
+            "IMG_640x480.jpg";
+        final String videoItemFilename3 = INPUT_FILE_PATH +
+            "H264_BP_640x480_30fps_192kbps_1_5.mp4";
+        final String videoItemFilename4 = INPUT_FILE_PATH +
+            "MPEG4_SP_640x480_15fps_256kbps_0_30.mp4";
+        final String videoItemFilename5 = INPUT_FILE_PATH +
+            "H263_profile0_176x144_10fps_96kbps_0_25.3gp";
+        final String maskFilename = INPUT_FILE_PATH +
+            "TransitionSpiral_QVGA.jpg";
+        boolean flagForException = false;
+        final MediaVideoItem mediaVideoItem1 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
+                videoItemFilename1, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mediaVideoItem1.setExtractBoundaries(0, 15000);
+        mVideoEditor.addMediaItem(mediaVideoItem1);
+
+        final MediaVideoItem mediaVideoItem2 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m2",
+                videoItemFilename2, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mediaVideoItem2.setExtractBoundaries(0, 15000);
+        mVideoEditor.addMediaItem(mediaVideoItem2);
+
+        final TransitionAlpha transition1And2 =
+            mVideoEditorHelper.createTAlpha("transition1And2", mediaVideoItem1,
+            mediaVideoItem2, 3000, Transition.BEHAVIOR_SPEED_UP, maskFilename,
+            10, false);
+        mVideoEditor.addTransition(transition1And2);
+
+        assertTrue("Transition ID",
+            transition1And2.getId().equals("transition1And2"));
+        assertEquals("Transtion After Media item", mediaVideoItem1,
+            transition1And2.getAfterMediaItem());
+        assertEquals("Transtion Before Media item", mediaVideoItem2,
+            transition1And2.getBeforeMediaItem());
+        assertEquals("Transtion Duration", 3000, transition1And2.getDuration());
+        assertEquals("Transtion Behavior", Transition.BEHAVIOR_SPEED_UP,
+            transition1And2.getBehavior());
+        assertTrue("Transition maskFile",
+            transition1And2.getMaskFilename().equals(maskFilename));
+        assertEquals("Transition BlendingPercent", 10,
+            transition1And2.getBlendingPercent());
+        assertFalse("Transition Invert", transition1And2.isInvert());
+
+        final MediaImageItem mediaImageItem3 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m3",
+                imageItemFilename1, 15000, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mVideoEditor.addMediaItem(mediaImageItem3);
+
+        final TransitionAlpha transition2And3 =
+            mVideoEditorHelper.createTAlpha("transition2And3", mediaVideoItem2,
+                mediaImageItem3, 1000, Transition.BEHAVIOR_SPEED_DOWN,
+                maskFilename, 30, false);
+        mVideoEditor.addTransition(transition2And3);
+
+        assertTrue("Transition ID",
+            transition2And3.getId().equals("transition2And3"));
+        assertEquals("Transtion After Media item", mediaVideoItem2,
+            transition2And3.getAfterMediaItem());
+        assertEquals("Transtion Before Media item", mediaImageItem3,
+            transition2And3.getBeforeMediaItem());
+        assertEquals("Transtion Duration", 1000, transition2And3.getDuration());
+        assertEquals("Transtion Behavior", Transition.BEHAVIOR_SPEED_DOWN,
+            transition2And3.getBehavior());
+        assertTrue("Transition maskFile",
+            transition2And3.getMaskFilename().equals(maskFilename));
+        assertEquals("Transition BlendingPercent", 30,
+            transition2And3.getBlendingPercent());
+        assertFalse("Transition Invert", transition2And3.isInvert());
+
+        final MediaVideoItem mediaVideoItem4 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m4",
+                videoItemFilename3, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mediaVideoItem4.setExtractBoundaries(0, 18000);
+        mVideoEditor.addMediaItem(mediaVideoItem4);
+
+        final TransitionAlpha transition3And4 =
+            mVideoEditorHelper.createTAlpha("transition3And4", mediaImageItem3,
+            mediaVideoItem4, 5000, Transition.BEHAVIOR_LINEAR, maskFilename,
+            50, false);
+        mVideoEditor.addTransition(transition3And4);
+
+        assertTrue("Transition ID",
+            transition3And4.getId().equals("transition3And4"));
+        assertEquals("Transtion After Media item", mediaImageItem3,
+            transition3And4.getAfterMediaItem());
+        assertEquals("Transtion Before Media item", mediaVideoItem4,
+            transition3And4.getBeforeMediaItem());
+        assertEquals("Transtion Duration", 5000, transition3And4.getDuration());
+        assertEquals("Transtion Behavior", Transition.BEHAVIOR_LINEAR,
+            transition3And4.getBehavior());
+        assertTrue("Transition maskFile",
+            transition3And4.getMaskFilename().equals(maskFilename));
+        assertEquals("Transition BlendingPercent", 50,
+            transition3And4.getBlendingPercent());
+        assertFalse("Transition Invert", transition3And4.isInvert());
+
+        final MediaVideoItem mediaVideoItem5 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m5",
+                videoItemFilename4, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mVideoEditor.addMediaItem(mediaVideoItem5);
+
+        final TransitionAlpha transition4And5 =
+            mVideoEditorHelper.createTAlpha("transition4And5", mediaVideoItem4,
+            mediaVideoItem5, 8000, Transition.BEHAVIOR_MIDDLE_FAST,
+            maskFilename, 70, true);
+        mVideoEditor.addTransition(transition4And5);
+
+        assertTrue("Transition ID",
+            transition4And5.getId().equals("transition4And5"));
+        assertEquals("Transtion After Media item", mediaVideoItem4,
+            transition4And5.getAfterMediaItem());
+        assertEquals("Transtion Before Media item", mediaVideoItem5,
+            transition4And5.getBeforeMediaItem());
+        assertEquals("Transtion Duration", 8000, transition4And5.getDuration());
+        assertEquals("Transtion Behavior", Transition.BEHAVIOR_MIDDLE_FAST,
+            transition4And5.getBehavior());
+        assertTrue("Transition maskFile",
+            transition4And5.getMaskFilename().equals(maskFilename));
+        assertEquals("Transition BlendingPercent", 70,
+            transition4And5.getBlendingPercent());
+        assertTrue("Transition Invert", transition4And5.isInvert());
+
+        final MediaVideoItem mediaVideoItem6 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m6",
+                videoItemFilename5, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mediaVideoItem6.setExtractBoundaries(0, 20000);
+        mVideoEditor.addMediaItem(mediaVideoItem6);
+
+        try {
+            mVideoEditorHelper.createTAlpha("transition5And6", mediaVideoItem5,
+                mediaVideoItem6, 2000, Transition.BEHAVIOR_MIDDLE_SLOW,
+                INPUT_FILE_PATH + "imDummyFile.jpg", 70,
+                true);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("MaskFile is not exsisting", flagForException);
+        flagForException = false;
+        try {
+            mVideoEditorHelper.createTAlpha("transition5And6", null, null, 2000,
+                Transition.BEHAVIOR_MIDDLE_SLOW, maskFilename, 101, true);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Invalid Blending Percent", flagForException);
+
+        flagForException = false;
+        try {
+            mVideoEditorHelper.createTAlpha("transitiond6", mediaVideoItem4,
+                mediaVideoItem5, 2000, Transition.BEHAVIOR_SPEED_UP - 1,
+                maskFilename, 30, false);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Transition FadeBlack with Invalid behavior", flagForException);
+        flagForException = false;
+        try {
+            mVideoEditorHelper.createTAlpha("transitiond6", mediaVideoItem4,
+                mediaVideoItem5, 2000, Transition.BEHAVIOR_MIDDLE_FAST + 1,
+                maskFilename, 30, false);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Transition FadeBlack with Invalid behavior", flagForException);
+    }
+
+    /**
+     * To test Frame Overlay for Media Video Item
+     */
+
+    // TODO : remove TC_API_041
+    @LargeTest
+    public void testFrameOverlayVideoItem() throws Exception {
+        final String videoItemFilename1 = INPUT_FILE_PATH +
+            "H263_profile0_176x144_10fps_256kbps_0_25.3gp";
+        final String overlayFile1 = INPUT_FILE_PATH +  "IMG_176x144_Overlay1.png";
+        final String overlayFile2 = INPUT_FILE_PATH +  "IMG_176x144_Overlay2.png";
+        final MediaVideoItem mediaVideoItem1 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
+                videoItemFilename1, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mVideoEditor.addMediaItem(mediaVideoItem1);
+
+        final Bitmap mBitmap1 =  mVideoEditorHelper.getBitmap(overlayFile1,
+            176, 144);
+        final OverlayFrame overlayFrame1 = mVideoEditorHelper.createOverlay(
+            mediaVideoItem1, "overlayId1", mBitmap1, 5000, 5000);
+        mediaVideoItem1.addOverlay(overlayFrame1);
+
+        assertEquals("Overlay : Media Item", mediaVideoItem1,
+            overlayFrame1.getMediaItem());
+        assertTrue("Overlay Id", overlayFrame1.getId().equals("overlayId1"));
+        assertEquals("Overlay Bitmap", mBitmap1, overlayFrame1.getBitmap());
+        assertEquals("Overlay Start Time", 5000, overlayFrame1.getStartTime());
+        assertEquals("Overlay Duration", 5000, overlayFrame1.getDuration());
+
+        Bitmap upddateBmp = mVideoEditorHelper.getBitmap(overlayFile2, 176, 144);
+        overlayFrame1.setBitmap(upddateBmp);
+        assertEquals("Overlay Update Bitmap", upddateBmp, overlayFrame1.getBitmap());
+        upddateBmp.recycle();
+    }
+
+    /**
+     * To test Frame Overlay for Media Video Item : Set duration and Get
+     * Duration
+     */
+
+    // TODO : remove TC_API_042
+    @LargeTest
+    public void testFrameOverlaySetAndGet() throws Exception {
+        final String videoItemFilename1 = INPUT_FILE_PATH +
+            "MPEG4_SP_640x480_30fps_512Kbps_0_27.mp4";
+        final String overlayFile1 = INPUT_FILE_PATH + "IMG_640x480_Overlay1.png";
+        boolean flagForException = false;
+
+        final Bitmap mBitmap =  mVideoEditorHelper.getBitmap(overlayFile1,
+            640, 480);
+
+        final MediaVideoItem mediaVideoItem1 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
+            videoItemFilename1, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mVideoEditor.addMediaItem(mediaVideoItem1);
+
+        final OverlayFrame overlayFrame1 = mVideoEditorHelper.createOverlay(
+            mediaVideoItem1, "overlayId1", mBitmap, 5000, 5000);
+        mediaVideoItem1.addOverlay(overlayFrame1);
+        overlayFrame1.setDuration(5000);
+
+        assertEquals("Overlay Duration", 5000, overlayFrame1.getDuration());
+        try {
+            overlayFrame1.setDuration(mediaVideoItem1.getDuration() + 10000);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Overlay Duration > MediaVideo Item Duration",
+            flagForException);
+
+        assertEquals("Overlay Duration", 5000, overlayFrame1.getDuration());
+        flagForException = false;
+
+        try {
+            overlayFrame1.setDuration(-1);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Overlay Duration = -1", flagForException);
+    }
+
+    /**
+     * To test Frame Overlay for Media Video Item : Set duration and Get
+     * Duration
+     */
+
+    // TODO : remove TC_API_043
+    @LargeTest
+    public void testFrameOverlayInvalidTime() throws Exception {
+        final String videoItemFilename1 = INPUT_FILE_PATH +
+            "MPEG4_SP_640x480_15fps_1200kbps_AACLC_48khz_64kbps_m_1_17.3gp";
+        final String overlayFile1 = INPUT_FILE_PATH + "IMG_640x480_Overlay1.png";
+        boolean flagForException = false;
+
+        final MediaVideoItem mediaVideoItem1 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
+                videoItemFilename1, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mVideoEditor.addMediaItem(mediaVideoItem1);
+
+        try {
+            final Bitmap mBitmap =  mVideoEditorHelper.getBitmap(overlayFile1,
+                640, 480);
+            mVideoEditorHelper.createOverlay(mediaVideoItem1, "overlayId1",
+                mBitmap, 400000000, 2000);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Overlay With Invalid Start Time", flagForException);
+
+        flagForException = false;
+        try {
+            final Bitmap mBitmap =  mVideoEditorHelper.getBitmap(overlayFile1,
+                640, 480);
+            mVideoEditorHelper.createOverlay(mediaVideoItem1, "overlayId2",
+                mBitmap, -1, 2000);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Overlay With Invalid Start Time", flagForException);
+
+        flagForException = false;
+        try {
+            final Bitmap mBitmap =  mVideoEditorHelper.getBitmap(overlayFile1,
+            640, 480);
+            mVideoEditorHelper.createOverlay(mediaVideoItem1, "overlayId3",
+                mBitmap, 2000, -1);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Overlay With Invalid Start Time", flagForException);
+    }
+
+    /**
+     * To test Frame Overlay for Media Image Item
+     */
+    // TODO : remove TC_API_045
+    @LargeTest
+    public void testFrameOverlayImageItem() throws Exception {
+        final String imageItemFilename1 = INPUT_FILE_PATH + "IMG_640x480.jpg";
+        final String overlayFile1 = INPUT_FILE_PATH + "IMG_640x480_Overlay1.png";
+        final String overlayFile2 = INPUT_FILE_PATH + "IMG_640x480_Overlay2.png";
+
+        final MediaImageItem mediaImageItem1 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
+                imageItemFilename1, 10000, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mVideoEditor.addMediaItem(mediaImageItem1);
+
+        final Bitmap mBitmap =  mVideoEditorHelper.getBitmap(overlayFile1, 640,
+            480);
+        final OverlayFrame overlayFrame1 = mVideoEditorHelper.createOverlay(
+            mediaImageItem1, "overlayId1", mBitmap, 5000, 5000);
+        mediaImageItem1.addOverlay(overlayFrame1);
+
+        assertEquals("Overlay : Media Item", mediaImageItem1,
+            overlayFrame1.getMediaItem());
+        assertTrue("Overlay Id", overlayFrame1.getId().equals("overlayId1"));
+        assertEquals("Overlay Bitmap",mBitmap ,overlayFrame1.getBitmap());
+        assertEquals("Overlay Start Time", 5000, overlayFrame1.getStartTime());
+        assertEquals("Overlay Duration", 5000, overlayFrame1.getDuration());
+        Bitmap upddateBmp = mVideoEditorHelper.getBitmap(overlayFile2, 640, 480);
+
+        overlayFrame1.setBitmap(upddateBmp);
+        assertEquals("Overlay Update Bitmap", upddateBmp, overlayFrame1.getBitmap());
+        upddateBmp.recycle();
+    }
+
+    /**
+     * To test Frame Overlay for Media Image Item : Set duration and Get
+     * Duration
+     */
+
+    // TODO : remove TC_API_046
+    @LargeTest
+    public void testFrameOverlaySetAndGetImage() throws Exception {
+        final String videoItemFilename1 = INPUT_FILE_PATH + "IMG_640x480.jpg";
+        final String overlayFile1 = INPUT_FILE_PATH + "IMG_640x480_Overlay1.png";
+        boolean flagForException = false;
+
+        final MediaImageItem mediaImageItem1 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
+                videoItemFilename1, 10000, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mVideoEditor.addMediaItem(mediaImageItem1);
+
+        final Bitmap mBitmap =  mVideoEditorHelper.getBitmap(overlayFile1,
+            640, 480);
+        final OverlayFrame overlayFrame1 = mVideoEditorHelper.createOverlay(
+            mediaImageItem1, "overlayId1", mBitmap, 5000, 5000);
+        mediaImageItem1.addOverlay(overlayFrame1);
+
+        overlayFrame1.setDuration(5000);
+        assertEquals("Overlay Duration", 5000, overlayFrame1.getDuration());
+
+        try {
+            overlayFrame1.setDuration(mediaImageItem1.getDuration() + 10000);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Overlay Duration > Media Item Duration", flagForException);
+        assertEquals("Overlay Duration", 5000, overlayFrame1.getDuration());
+
+        flagForException = false;
+        try {
+            overlayFrame1.setDuration(-1);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Overlay Duration = -1", flagForException);
+    }
+
+    /**
+     * To test  Frame Overlay for  Media Image Item :Invalid StartTime and
+     * Duration
+     */
+
+    // TODO : remove TC_API_047
+    @LargeTest
+    public void testFrameOverlayInvalidTimeImage() throws Exception {
+        final String videoItemFilename1 = INPUT_FILE_PATH + "IMG_640x480.jpg";
+        final String overlayFile1 = INPUT_FILE_PATH + "IMG_640x480_Overlay1.png";
+        boolean flagForException = false;
+
+        final MediaImageItem mediaImageItem1 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
+                videoItemFilename1, 10000, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mVideoEditor.addMediaItem(mediaImageItem1);
+
+        try {
+            final Bitmap mBitmap =  mVideoEditorHelper.getBitmap(overlayFile1,
+                640, 480);
+            mVideoEditorHelper.createOverlay(mediaImageItem1, "overlayId1",
+                mBitmap, 400000000, 2000);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Overlay With Invalid Start Time", flagForException);
+
+        flagForException = false;
+        try {
+            final Bitmap mBitmap =  mVideoEditorHelper.getBitmap(overlayFile1,
+                640, 480);
+            mVideoEditorHelper.createOverlay(mediaImageItem1, "overlayId2",
+                mBitmap, -1, 2000);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Overlay With Invalid Start Time", flagForException);
+
+        flagForException = false;
+        try {
+            final Bitmap mBitmap =  mVideoEditorHelper.getBitmap(overlayFile1,
+                640, 480);
+            mVideoEditorHelper.createOverlay(mediaImageItem1, "overlayId3",
+                mBitmap, 2000, -1);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Overlay With Invalid Start Time", flagForException);
+    }
+
+    /**
+     * To Test Frame Overlay Media Image Item :JPG File
+     */
+
+    // TODO : remove TC_API_048
+    @LargeTest
+    public void testFrameOverlayJPGImage() throws Exception {
+
+        final String imageItemFilename = INPUT_FILE_PATH + "IMG_640x480.jpg";
+        final String overlayFile1 = INPUT_FILE_PATH + "IMG_640x480_Overlay1.png";
+        boolean flagForException = false;
+        final MediaImageItem mediaImageItem1 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
+                imageItemFilename, 10000, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mVideoEditor.addMediaItem(mediaImageItem1);
+        final Bitmap mBitmap =  mVideoEditorHelper.getBitmap(overlayFile1, 640,
+            480);
+        mVideoEditorHelper.createOverlay(mediaImageItem1, "overlayId1",
+            mBitmap, 5000, 5000);
+    }
+
+    /**
+     * To test Video Editor API
+     *
+     * @throws Exception
+     */
+    // TODO : remove TC_API_049
+    @LargeTest
+    public void testVideoEditorAPI() throws Exception {
+
+        final String videoItemFileName1 = INPUT_FILE_PATH
+            + "MPEG4_SP_720x480_30fps_280kbps_AACLC_48kHz_96kbps_s_0_21.mp4";
+        final String videoItemFileName2 = INPUT_FILE_PATH +
+            "MPEG4_SP_640x480_15fps_1200kbps_AACLC_48khz_64kbps_m_1_17.3gp";
+        final String videoItemFileName3 = INPUT_FILE_PATH
+            + "MPEG4_SP_640x480_15fps_512kbps_AACLC_48khz_132kbps_s_0_26.mp4";
+        final String imageItemFileName1 = INPUT_FILE_PATH + "IMG_640x480.jpg";
+        final String imageItemFileName2 = INPUT_FILE_PATH + "IMG_176x144.jpg";
+        final String audioFilename1 = INPUT_FILE_PATH +
+            "AMRNB_8KHz_12.2Kbps_m_1_17.3gp";
+        final String audioFilename2 = INPUT_FILE_PATH +
+            "AACLC_48KHz_256Kbps_s_1_17.3gp";
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        boolean flagForException = false;
+        TransitionCrossfade transition2And4;
+
+        final MediaVideoItem mediaVideoItem1 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
+                videoItemFileName1, renderingMode);
+        mediaVideoItem1.setExtractBoundaries(0, 10000);
+        mVideoEditor.addMediaItem(mediaVideoItem1);
+
+        final MediaVideoItem mediaVideoItem2 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m2",
+                videoItemFileName2, renderingMode);
+        mediaVideoItem2.setExtractBoundaries(mediaVideoItem2.getDuration() / 4,
+            mediaVideoItem2.getDuration() / 2);
+        mVideoEditor.addMediaItem(mediaVideoItem2);
+
+        final MediaVideoItem mediaVideoItem3 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m3",
+                videoItemFileName3, renderingMode);
+        mediaVideoItem3.setExtractBoundaries(mediaVideoItem3.getDuration() / 2,
+            mediaVideoItem3.getDuration());
+        mVideoEditor.addMediaItem(mediaVideoItem3);
+
+        final MediaImageItem mediaImageItem1 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m4",
+                imageItemFileName1, 5000, renderingMode);
+
+        final MediaImageItem mediaImageItem2 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m5",
+                imageItemFileName2, 5000, renderingMode);
+
+        List<MediaItem> mediaList = mVideoEditor.getAllMediaItems();
+        assertEquals("Media Item List Size", 3, mediaList.size());
+
+        mVideoEditor.insertMediaItem(mediaImageItem1, mediaVideoItem2.getId());
+        mediaList = mVideoEditor.getAllMediaItems();
+        assertEquals("Media Item List Size", 4, mediaList.size());
+        assertEquals("Media item 1", mediaVideoItem1, mediaList.get(0));
+        assertEquals("Media item 2", mediaVideoItem2, mediaList.get(1));
+        assertEquals("Media item 4", mediaImageItem1, mediaList.get(2));
+        assertEquals("Media item 3", mediaVideoItem3, mediaList.get(3));
+
+        mVideoEditor.insertMediaItem(mediaImageItem2, mediaImageItem1.getId());
+        mediaList = mVideoEditor.getAllMediaItems();
+        assertEquals("Media Item List Size", 5, mediaList.size());
+        assertEquals("Media item 1", mediaVideoItem1, mediaList.get(0));
+        assertEquals("Media item 2", mediaVideoItem2, mediaList.get(1));
+        assertEquals("Media item 4", mediaImageItem1, mediaList.get(2));
+        assertEquals("Media item 5", mediaImageItem2, mediaList.get(3));
+        assertEquals("Media item 3", mediaVideoItem3, mediaList.get(4));
+
+        mVideoEditor.moveMediaItem(mediaVideoItem1.getId(), mediaImageItem2.getId());
+        mediaList = mVideoEditor.getAllMediaItems();
+        assertEquals("Media Item List Size", 5, mediaList.size());
+        assertEquals("Media item 2", mediaVideoItem2, mediaList.get(0));
+        assertEquals("Media item 4", mediaImageItem1, mediaList.get(1));
+        assertEquals("Media item 5", mediaImageItem2, mediaList.get(2));
+        assertEquals("Media item 1", mediaVideoItem1, mediaList.get(3));
+        assertEquals("Media item 3", mediaVideoItem3, mediaList.get(4));
+
+        assertEquals("Media Item 1", mediaVideoItem1,
+            mVideoEditor.getMediaItem(mediaVideoItem1.getId()));
+
+        flagForException = false;
+        transition2And4 = null;
+        try{
+            transition2And4 = mVideoEditorHelper.createTCrossFade(
+                "transition2And4", mediaVideoItem2, mediaImageItem1, 2000,
+                Transition.BEHAVIOR_MIDDLE_FAST);
+            mVideoEditor.addTransition(transition2And4);
+        }
+        catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertFalse("Transition2and4 cannot be created", flagForException);
+
+
+        TransitionCrossfade transition1And3 = null;
+        flagForException = false;
+        try{
+            transition1And3 = mVideoEditorHelper.createTCrossFade(
+                "transition1And3", mediaVideoItem1, mediaVideoItem2, 5000,
+                Transition.BEHAVIOR_MIDDLE_FAST);
+                mVideoEditor.addTransition(transition1And3);
+            }catch (IllegalArgumentException e) {
+                flagForException = true;
+            }
+        assertTrue("Transition1and3 cannot be created", flagForException);
+
+        List<Transition> transitionList = mVideoEditor.getAllTransitions();
+        assertEquals("Transition List", 1, transitionList.size());
+
+        assertEquals("Transition 2", transition2And4,
+            mVideoEditor.getTransition(transition2And4.getId()));
+
+        final AudioTrack audioTrack = mVideoEditorHelper.createAudio(
+            mVideoEditor, "audioTrack", audioFilename1);
+        mVideoEditor.addAudioTrack(audioTrack);
+
+        List<AudioTrack> audioList = mVideoEditor.getAllAudioTracks();
+        assertEquals("Audio List", 1, audioList.size());
+
+        final AudioTrack audioTrack1 = mVideoEditorHelper.createAudio(
+            mVideoEditor, "audioTrack1", audioFilename2);
+        flagForException = false;
+        try {
+            mVideoEditor.addAudioTrack(audioTrack1);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Audio Track support is 1 ", flagForException);
+
+        flagForException = false;
+        try {
+            mVideoEditor.insertAudioTrack(audioTrack1,"audioTrack");
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Audio Track supports is 1 ", flagForException);
+
+        assertEquals("Removing AudioTrack", audioTrack,
+            mVideoEditor.removeAudioTrack(audioTrack.getId()));
+
+        assertEquals("Removing transition", transition2And4,
+            mVideoEditor.removeTransition(transition2And4.getId()));
+
+        assertEquals("Removing Media Item", mediaVideoItem2,
+            mVideoEditor.removeMediaItem(mediaVideoItem2.getId()));
+
+        mVideoEditor.setAspectRatio(MediaProperties.ASPECT_RATIO_16_9);
+        assertEquals("Check Aspect Ratio", MediaProperties.ASPECT_RATIO_16_9,
+            mVideoEditor.getAspectRatio());
+
+        long storyBoardDuration = mediaVideoItem1.getTimelineDuration()
+            + mediaVideoItem3.getTimelineDuration()
+            + mediaImageItem1.getDuration()
+            + mediaImageItem2.getDuration();
+        assertEquals("Story Board Duration", storyBoardDuration,
+            mVideoEditor.getDuration());
+    }
+
+    /**
+     * To add Audio Track Greater than MediaItem Duration
+     *
+     * @throws Exception
+     */
+    // TODO : remove TC_API_050
+    @LargeTest
+    public void testVideoLessThanAudio() throws Exception {
+        final String videoItemFileName1 = INPUT_FILE_PATH
+            + "MPEG4_SP_720x480_30fps_280kbps_AACLC_48kHz_96kbps_s_0_21.mp4";
+        final String audioTrackFilename = INPUT_FILE_PATH +
+            "AACLC_48KHz_256Kbps_s_1_17.3gp";
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+
+        final MediaVideoItem mediaVideoItem1 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
+                videoItemFileName1, renderingMode);
+        mVideoEditor.addMediaItem(mediaVideoItem1);
+        final AudioTrack audioTrack = mVideoEditorHelper.createAudio(
+            mVideoEditor, "audioTrackId", audioTrackFilename);
+        mVideoEditor.addAudioTrack(audioTrack);
+        assertEquals("Storyboard = mediaItem Duration",
+            mediaVideoItem1.getDuration(), mVideoEditor.getDuration());
+        assertTrue("Audio Duration > mediaItem Duration",
+            (audioTrack.getDuration() > mediaVideoItem1.getDuration() ?
+            true : false));
+    }
+
+    /**
+     * To test Video Editor API with 1080 P
+     *
+     * @throws Exception
+     */
+    // TODO : remove TC_API_051
+    @LargeTest
+    public void testVideoContentHD() throws Exception {
+        final String videoItemFileName1 = INPUT_FILE_PATH
+            + "H264_BP_1920x1080_30fps_1200Kbps_1_10.mp4";
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        final MediaVideoItem mediaVideoItem1;
+        boolean flagForException = false;
+        try {
+            mediaVideoItem1 = mVideoEditorHelper.createMediaItem(mVideoEditor,
+                "m1", videoItemFileName1, renderingMode);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("VideoContent 1920x1080", flagForException);
+    }
+
+
+    /**
+     * To test: Remove audio track
+     *
+     * @throws Exception
+     */
+    // TODO : remove TC_API_052
+    @LargeTest
+    public void testRemoveAudioTrack() throws Exception {
+        final String audioFileName = INPUT_FILE_PATH +
+            "AACLC_48KHz_256Kbps_s_1_17.3gp";
+        boolean flagForException = false;
+
+        final AudioTrack audioTrack = mVideoEditorHelper.createAudio(
+            mVideoEditor, "audioTrack1", audioFileName);
+        mVideoEditor.addAudioTrack(audioTrack);
+
+        assertEquals("Audio Track Item Duration", audioTrack.getDuration(),
+            audioTrack.getTimelineDuration());
+        assertTrue("Audio Track ID", audioTrack.getId().equals("audioTrack1"));
+        assertNotNull("Remove Audio Track",
+            mVideoEditor.removeAudioTrack("audioTrack1"));
+        try{
+            mVideoEditor.removeAudioTrack("audioTrack1");
+        }catch (IllegalArgumentException e){
+            flagForException = true;
+        }
+        assertTrue("Remove Audio Track not possible", flagForException);
+    }
+
+      /**
+     * To test: Disable ducking
+     *
+     * @throws Exception
+     */
+    // TODO : remove TC_API_053
+    @LargeTest
+    public void testAudioDuckingDisable() throws Exception {
+        final String audioFileName = INPUT_FILE_PATH +
+            "AACLC_48KHz_256Kbps_s_1_17.3gp";
+        final AudioTrack audioTrack = mVideoEditorHelper.createAudio(
+            mVideoEditor, "audioTrack", audioFileName);
+        mVideoEditor.addAudioTrack(audioTrack);
+
+        audioTrack.disableDucking();
+        assertFalse("Audio Track Ducking is Disabled",
+            audioTrack.isDuckingEnabled());
+    }
+
+
+    // TODO : remove TC_API_054
+    /** This test case is added with Test case ID TC_API_010 */
+
+      /**
+     * To test: Need a basic test case for the get value for TransitionAlpha
+     *  ( ie. getBlendingPercent, getMaskFilename, isInvert)
+     *
+     * @throws Exception
+     */
+    // TODO : remove TC_API_055
+    @LargeTest
+    public void testTransitionAlphaBasic() throws Exception {
+
+        final String videoItemFilename1 = INPUT_FILE_PATH +
+            "H264_BP_640x480_30fps_256kbps_1_17.mp4";
+        final String maskFilename = INPUT_FILE_PATH + "IMG_640x480_Overlay1.png";
+        boolean flagForException = false;
+
+        final MediaVideoItem mediaVideoItem1 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
+                videoItemFilename1, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mediaVideoItem1.setExtractBoundaries(0, 15000);
+
+        final MediaImageItem mediaImageItem =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m2", maskFilename,
+                10000, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mediaImageItem.setDuration(15000);
+
+        mVideoEditor.addMediaItem(mediaVideoItem1);
+        mVideoEditor.addMediaItem(mediaImageItem);
+        final TransitionAlpha transition1And2 =
+            mVideoEditorHelper.createTAlpha("transition1And2", mediaVideoItem1,
+                mediaImageItem, 3000, Transition.BEHAVIOR_SPEED_UP,
+                maskFilename, 10, false);
+        mVideoEditor.addTransition(transition1And2);
+        assertTrue("Transition maskFile",
+            transition1And2.getMaskFilename().equals(maskFilename));
+        assertEquals("Transition BlendingPercent", 10,
+            transition1And2.getBlendingPercent());
+        assertFalse("Transition Invert", transition1And2.isInvert());
+    }
+
+    /**
+     * To test: NULL arguments to the Video Editor APIs
+     *
+     * @throws Exception
+     */
+    // TODO : remove TC_API_056
+    @LargeTest
+    public void testNullAPIs() throws Exception {
+
+        final String videoItemFilename1 = INPUT_FILE_PATH +
+            "H264_BP_640x480_30fps_256kbps_1_17.mp4";
+        final String maskFilename = INPUT_FILE_PATH +
+            "IMG_640x480_Overlay1.png";
+        final String audioFileName = INPUT_FILE_PATH +
+            "AACLC_48KHz_256Kbps_s_1_17.3gp";
+        boolean flagForException = false;
+
+        try {
+            mVideoEditor.addAudioTrack(null);
+        } catch(IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Video Editor with null Audio Track", flagForException);
+        flagForException = false;
+        try {
+            mVideoEditor.addMediaItem(null);
+        } catch(IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Video Editor with NULL Image Item ", flagForException);
+        flagForException = false;
+        try {
+            mVideoEditor.addMediaItem(null);
+        } catch(IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Video Editor with NULL Video Item ", flagForException);
+
+        MediaVideoItem mediaVideoItem1 = null;
+        try {
+            mediaVideoItem1 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
+                videoItemFilename1, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        } catch (IllegalArgumentException e) {
+            assertTrue("Cannot Create Video Item", false);
+        }
+        mediaVideoItem1.setExtractBoundaries(0, 15000);
+        mVideoEditor.addMediaItem(mediaVideoItem1);
+        flagForException = false;
+        try {
+            mediaVideoItem1.addEffect(null);
+        } catch(IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Video with null effect ", flagForException);
+        flagForException = false;
+        try {
+            mediaVideoItem1.addOverlay(null);
+        } catch(IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Video with null overlay ", flagForException);
+
+        final MediaImageItem mediaImageItem =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m2", maskFilename,
+                10000, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mediaImageItem.setDuration(15000);
+        mVideoEditor.addMediaItem(mediaImageItem);
+        flagForException = false;
+        try {
+            mediaImageItem.addEffect(null);
+        } catch(IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Image with null effect ", flagForException);
+        flagForException = false;
+        try {
+            mediaImageItem.addOverlay(null);
+        } catch(IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Image with null overlay ", flagForException);
+
+        final AudioTrack audioTrack = mVideoEditorHelper.createAudio(
+            mVideoEditor, "audioTrack", audioFileName);
+        mVideoEditor.addAudioTrack(audioTrack);
+
+        flagForException = false;
+        try {
+            mVideoEditor.addTransition(null);
+        } catch(IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Added null transition ", flagForException);
+
+        flagForException = false;
+        try {
+            mVideoEditor.addTransition(null);
+        } catch(IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Added null transition ", flagForException);
+
+    }
+}
diff --git a/media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/functional/VideoEditorExportTest.java b/media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/functional/VideoEditorExportTest.java
new file mode 100755
index 0000000..fdd5091
--- /dev/null
+++ b/media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/functional/VideoEditorExportTest.java
@@ -0,0 +1,819 @@
+/*
+ * Copyright (C) 2011 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.
+ */
+
+package com.android.mediaframeworktest.functional;
+
+import java.io.File;
+
+import android.graphics.Bitmap;
+import android.graphics.Rect;
+import android.media.videoeditor.AudioTrack;
+import android.media.videoeditor.EffectColor;
+import android.media.videoeditor.EffectKenBurns;
+import android.media.videoeditor.MediaImageItem;
+import android.media.videoeditor.MediaItem;
+import android.media.videoeditor.MediaProperties;
+import android.media.videoeditor.MediaVideoItem;
+import android.media.videoeditor.OverlayFrame;
+import android.media.videoeditor.Transition;
+import android.media.videoeditor.TransitionAlpha;
+import android.media.videoeditor.TransitionCrossfade;
+import android.media.videoeditor.TransitionFadeBlack;
+import android.media.videoeditor.TransitionSliding;
+import android.media.videoeditor.VideoEditor;
+import android.media.videoeditor.VideoEditor.ExportProgressListener;
+import android.media.videoeditor.VideoEditor.MediaProcessingProgressListener;
+import android.os.Environment;
+import android.test.ActivityInstrumentationTestCase;
+
+
+import android.util.Log;
+
+import com.android.mediaframeworktest.MediaFrameworkTest;
+import android.test.suitebuilder.annotation.LargeTest;
+import com.android.mediaframeworktest.VideoEditorHelper;
+
+public class VideoEditorExportTest extends
+    ActivityInstrumentationTestCase<MediaFrameworkTest> {
+    private final String TAG = "TransitionTest";
+
+    private final String PROJECT_LOCATION = VideoEditorHelper.PROJECT_LOCATION_COMMON;
+
+    private final String INPUT_FILE_PATH = VideoEditorHelper.INPUT_FILE_PATH_COMMON;
+
+    private VideoEditor mVideoEditor;
+
+    private VideoEditorHelper mVideoEditorHelper;
+
+    // Declares the annotation for Preview Test Cases
+    public @interface TransitionTests {
+    }
+
+    public VideoEditorExportTest() {
+        super("com.android.mediaframeworktest", MediaFrameworkTest.class);
+    }
+
+    @Override
+    protected void setUp() throws Exception {
+        // setup for each test case.
+        super.setUp();
+        mVideoEditorHelper = new VideoEditorHelper();
+        // Create a random String which will be used as project path, where all
+        // project related files will be stored.
+        final String projectPath =
+            mVideoEditorHelper.createRandomFile(PROJECT_LOCATION);
+        mVideoEditor = mVideoEditorHelper.createVideoEditor(projectPath);
+    }
+
+    @Override
+    protected void tearDown() throws Exception {
+        mVideoEditorHelper.destroyVideoEditor(mVideoEditor);
+        // Clean the directory created as project path
+        mVideoEditorHelper.deleteProject(new File(mVideoEditor.getPath()));
+        System.gc();
+        super.tearDown();
+    }
+
+    /**
+     * To Test export : Merge and Trim different types of Video and Image files
+     */
+    // TODO :remove TC_EXP_001
+    @LargeTest
+    public void testExportMergeTrim() throws Exception {
+        final String videoItemFilename1 = INPUT_FILE_PATH
+            + "H263_profile0_176x144_15fps_256kbps_AACLC_32kHz_128kbps_s_0_26.3gp";
+        final String imageItemFilename1 = INPUT_FILE_PATH + "IMG_1600x1200.jpg";
+        final String videoItemFilename2 = INPUT_FILE_PATH
+            + "H264_BP_640x480_12.5fps_256kbps_AACLC_16khz_24kbps_s_0_26.mp4";
+        final String videoItemFilename3 = INPUT_FILE_PATH
+            + "MPEG4_SP_720x480_30fps_280kbps_AACLC_48kHz_96kbps_s_0_21.mp4";
+        final String imageItemFilename2 = INPUT_FILE_PATH + "IMG_176x144.jpg";
+        final String imageItemFilename3 = INPUT_FILE_PATH + "IMG_640x480.jpg";
+        final String outFilename = mVideoEditorHelper
+            .createRandomFile(mVideoEditor.getPath() + "/")
+            + ".3gp";
+
+        final MediaVideoItem mediaVideoItem1 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
+                videoItemFilename1, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mediaVideoItem1.setExtractBoundaries(2000, 7000);
+        mVideoEditor.addMediaItem(mediaVideoItem1);
+
+        final MediaImageItem mediaImageItem2 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m2",
+                imageItemFilename1, 3000, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mVideoEditor.addMediaItem(mediaImageItem2);
+
+        final MediaVideoItem mediaVideoItem3 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m3",
+                videoItemFilename2, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mediaVideoItem3.setExtractBoundaries(0, 2000);
+        mVideoEditor.addMediaItem(mediaVideoItem3);
+
+        final MediaVideoItem mediaVideoItem4 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m4",
+                videoItemFilename3, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mediaVideoItem4.setExtractBoundaries(mediaVideoItem4.getDuration()-5000,
+            mediaVideoItem4.getDuration());
+        mVideoEditor.addMediaItem(mediaVideoItem4);
+
+        final MediaImageItem mediaImageItem5 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m5",
+                imageItemFilename2, 4000, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mVideoEditor.addMediaItem(mediaImageItem5);
+
+        final MediaImageItem mediaImageItem6 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m6",
+                imageItemFilename3, 2000, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mVideoEditor.addMediaItem(mediaImageItem6);
+
+        mVideoEditor.generatePreview(new MediaProcessingProgressListener() {
+            public void onProgress(Object item, int action, int progress) {
+            }
+        });
+
+        try {
+            final int[] progressUpdate = new int[100];
+            mVideoEditor.export(outFilename, MediaProperties.HEIGHT_720,
+                MediaProperties.BITRATE_800K, new ExportProgressListener() {
+                    int i = 0;
+                    public void onProgress(VideoEditor ve, String outFileName,
+                        int progress) {
+                            progressUpdate[i++] = progress;
+                    }
+                });
+            mVideoEditorHelper.checkProgressCBValues(progressUpdate);
+        } catch (Exception e) {
+            assertTrue("Error in Export" + e.toString(), false);
+        }
+        final long storyBoardDuration = mediaVideoItem1.getTimelineDuration()
+            + mediaImageItem2.getDuration() + mediaVideoItem3.getTimelineDuration()
+            + mediaVideoItem4.getTimelineDuration() + mediaImageItem5.getDuration()
+            + mediaImageItem6.getDuration();
+        mVideoEditorHelper.validateExport(mVideoEditor, outFilename,
+            MediaProperties.HEIGHT_720, 0, storyBoardDuration,
+            MediaProperties.VCODEC_H264BP, MediaProperties.ACODEC_AAC_LC);
+        mVideoEditorHelper.checkDeleteExistingFile(outFilename);
+    }
+
+    /**
+     *To Test export : With Effect and Overlays on Different Media Items
+     */
+    // TODO :remove TC_EXP_002
+    @LargeTest
+    public void testExportEffectOverlay() throws Exception {
+          final String videoItemFilename1 = INPUT_FILE_PATH
+            + "H263_profile0_176x144_15fps_256kbps_AACLC_32kHz_128kbps_s_0_26.3gp";
+        final String imageItemFilename1 = INPUT_FILE_PATH + "IMG_1600x1200.jpg";
+        final String videoItemFilename2 = INPUT_FILE_PATH
+              + "H264_BP_640x480_15fps_1200Kbps_AACLC_48KHz_64kps_m_0_27.3gp";
+        final String videoItemFilename3 = INPUT_FILE_PATH
+            + "MPEG4_SP_720x480_30fps_280kbps_AACLC_48kHz_96kbps_s_0_21.mp4";
+        final String imageItemFilename2 = INPUT_FILE_PATH + "IMG_176x144.jpg";
+        final String imageItemFilename3 = INPUT_FILE_PATH + "IMG_640x480.jpg";
+        final String outFilename = mVideoEditorHelper
+            .createRandomFile(mVideoEditor.getPath() + "/") + ".3gp";
+
+        final String overlayFile = INPUT_FILE_PATH + "IMG_640x480_Overlay1.png";
+
+        final MediaVideoItem mediaVideoItem1 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
+                videoItemFilename1, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mediaVideoItem1.setExtractBoundaries(2000, 7000);
+        mVideoEditor.addMediaItem(mediaVideoItem1);
+
+        final EffectColor effectPink =
+            mVideoEditorHelper.createEffectItem(mediaVideoItem1, "effectPink",
+                0, 2000, EffectColor.TYPE_COLOR, EffectColor.PINK);
+        mediaVideoItem1.addEffect(effectPink);
+
+        final EffectColor effectNegative =
+            mVideoEditorHelper.createEffectItem(mediaVideoItem1, "effectNegative",
+                3000, 4000, EffectColor.TYPE_NEGATIVE, 0);
+        mediaVideoItem1.addEffect(effectNegative);
+
+        final MediaImageItem mediaImageItem2 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m2",
+                imageItemFilename1, 3000, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mVideoEditor.addMediaItem(mediaImageItem2);
+
+        final EffectColor effectFifties =
+            mVideoEditorHelper.createEffectItem(mediaImageItem2, "effectFifties",
+                0, 3000, EffectColor.TYPE_FIFTIES, 0);
+        mediaImageItem2.addEffect(effectFifties);
+
+        final MediaVideoItem mediaVideoItem3 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m3",
+                videoItemFilename2, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mVideoEditor.addMediaItem(mediaVideoItem3);
+        mediaVideoItem3.setExtractBoundaries(0, 8000);
+
+        final Bitmap mBitmap =  mVideoEditorHelper.getBitmap(overlayFile,
+            640, 480);
+        final OverlayFrame overlayFrame =
+            mVideoEditorHelper.createOverlay(mediaVideoItem3, "overlay",
+                mBitmap, 2000, 5000);
+        mediaVideoItem3.addOverlay(overlayFrame);
+
+        final EffectColor effectGreen =
+            mVideoEditorHelper.createEffectItem(mediaVideoItem3, "effectGreen",
+                0, 2000, EffectColor.TYPE_COLOR, EffectColor.GREEN);
+        mediaVideoItem3.addEffect(effectGreen);
+
+        final MediaVideoItem mediaVideoItem4 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m4",
+                videoItemFilename3, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mediaVideoItem4.setExtractBoundaries(mediaVideoItem4.getDuration()-5000,
+            mediaVideoItem4.getDuration());
+        mVideoEditor.addMediaItem(mediaVideoItem4);
+
+        final EffectColor effectSepia =
+            mVideoEditorHelper.createEffectItem(mediaVideoItem4, "effectSepia",
+                0, 2000, EffectColor.TYPE_SEPIA, 0);
+        mediaVideoItem4.addEffect(effectSepia);
+
+        final MediaImageItem mediaImageItem5 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m5",
+                imageItemFilename2, 4000, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mVideoEditor.addMediaItem(mediaImageItem5);
+
+        final EffectColor effectGray =
+            mVideoEditorHelper.createEffectItem(mediaImageItem5, "effectGray",
+                0, 2000, EffectColor.TYPE_COLOR, EffectColor.GRAY);
+        mediaImageItem5.addEffect(effectGray);
+
+        final MediaImageItem mediaImageItem6 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m6",
+                imageItemFilename3, 2000, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mVideoEditor.addMediaItem(mediaImageItem6);
+
+        final EffectColor effectGradient =
+            mVideoEditorHelper.createEffectItem(mediaImageItem6,
+                "effectGradient", 0, 2000, EffectColor.TYPE_GRADIENT,
+                EffectColor.PINK);
+        mediaImageItem6.addEffect(effectGradient);
+
+        mVideoEditor.generatePreview(new MediaProcessingProgressListener() {
+            public void onProgress(Object item, int action, int progress) {
+            }
+        });
+
+        try {
+            final int[] progressUpdate = new int[100];
+            mVideoEditor.export(outFilename, MediaProperties.HEIGHT_720,
+                MediaProperties.BITRATE_800K, new ExportProgressListener() {
+                    int i = 0;
+                    public void onProgress(VideoEditor ve, String outFileName,
+                        int progress) {
+                            progressUpdate[i++] = progress;
+                    }
+                });
+            mVideoEditorHelper.checkProgressCBValues(progressUpdate);
+        } catch (Exception e) {
+            assertTrue("Error in Export" + e.toString(), false);
+        }
+        final long storyBoardDuration = mediaVideoItem1.getTimelineDuration()
+            + mediaImageItem2.getDuration()
+            + mediaVideoItem3.getTimelineDuration()
+            + mediaVideoItem4.getTimelineDuration()
+            + mediaImageItem5.getDuration()
+            + mediaImageItem6.getDuration();
+        mVideoEditorHelper.validateExport(mVideoEditor, outFilename,
+            MediaProperties.HEIGHT_720, 0, storyBoardDuration,
+            MediaProperties.VCODEC_H264BP, MediaProperties.ACODEC_AAC_LC);
+        mVideoEditorHelper.checkDeleteExistingFile(outFilename);
+    }
+
+    /**
+     * To test export : with Image with KenBurnEffect
+     */
+    // TODO : remove TC_EXP_003
+    @LargeTest
+    public void testExportEffectKenBurn() throws Exception {
+        final String imageItemFileName = INPUT_FILE_PATH + "IMG_640x480.jpg";
+        final int imageItemRenderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        final String outFilename = mVideoEditorHelper
+            .createRandomFile(mVideoEditor.getPath() + "/") + ".3gp";
+
+        final MediaImageItem mediaImageItem =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "mediaImageItem1",
+                imageItemFileName, 5000, imageItemRenderingMode);
+        mVideoEditor.addMediaItem(mediaImageItem);
+
+        final Rect startRect = new Rect((mediaImageItem.getHeight() / 3),
+            (mediaImageItem.getWidth() / 3), (mediaImageItem.getHeight() / 2),
+            (mediaImageItem.getWidth() / 2));
+
+        final Rect endRect = new Rect(0, 0, mediaImageItem.getWidth(),
+            mediaImageItem.getHeight());
+
+        final EffectKenBurns kbEffectOnMediaItem = new EffectKenBurns(
+            mediaImageItem, "KBOnM2", startRect, endRect, 500, 3000);
+        assertNotNull("EffectKenBurns", kbEffectOnMediaItem);
+        mediaImageItem.addEffect(kbEffectOnMediaItem);
+
+        assertEquals("KenBurn Start Rect", startRect,
+            kbEffectOnMediaItem.getStartRect());
+        assertEquals("KenBurn End Rect", endRect,
+            kbEffectOnMediaItem.getEndRect());
+
+        mVideoEditor.generatePreview(new MediaProcessingProgressListener() {
+            public void onProgress(Object item, int action, int progress) {
+            }
+        });
+
+        try {
+            final int[] progressUpdate = new int[100];
+            mVideoEditor.export(outFilename, MediaProperties.HEIGHT_720,
+                MediaProperties.BITRATE_800K, new ExportProgressListener() {
+                    int i = 0;
+                    public void onProgress(VideoEditor ve, String outFileName,
+                        int progress) {
+                            progressUpdate[i++] = progress;
+                    }
+                });
+            mVideoEditorHelper.checkProgressCBValues(progressUpdate);
+        } catch (Exception e) {
+            assertTrue("Error in Export" + e.toString(), false);
+        }
+        mVideoEditorHelper.validateExport(mVideoEditor, outFilename,
+            MediaProperties.HEIGHT_720, 0, mediaImageItem.getDuration(),
+            MediaProperties.VCODEC_H264BP, MediaProperties.ACODEC_AAC_LC);
+        mVideoEditorHelper.checkDeleteExistingFile(outFilename);
+    }
+
+    /**
+     * To Test Export : With Video and Image and An Audio BackGround Track
+     */
+    // TODO : remove TC_EXP_004
+    @LargeTest
+    public void testExportAudio() throws Exception {
+        final String videoItemFileName = INPUT_FILE_PATH
+            + "H263_profile0_176x144_15fps_256kbps_AACLC_32kHz_128kbps_s_0_26.3gp";
+        final String imageItemFileName = INPUT_FILE_PATH + "IMG_1600x1200.jpg";
+        final String outFilename = mVideoEditorHelper
+            .createRandomFile(mVideoEditor.getPath() + "/") + ".3gp";
+        final String audioTrackFilename = INPUT_FILE_PATH +
+            "AMRNB_8KHz_12.2Kbps_m_1_17.3gp";
+
+        final MediaVideoItem mediaVideoItem =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
+                videoItemFileName, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mediaVideoItem.setExtractBoundaries(0, 10000);
+        mVideoEditor.addMediaItem(mediaVideoItem);
+
+        final MediaImageItem mediaImageItem =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m2",
+                imageItemFileName, 5000, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mVideoEditor.addMediaItem(mediaImageItem);
+
+        final AudioTrack audioTrack = mVideoEditorHelper.createAudio(
+            mVideoEditor, "a1", audioTrackFilename);
+        audioTrack.setExtractBoundaries(2000, 5000);
+        mVideoEditor.addAudioTrack(audioTrack);
+
+        audioTrack.disableDucking();
+        audioTrack.enableLoop();
+        audioTrack.setVolume(75);
+
+        mVideoEditor.generatePreview(new MediaProcessingProgressListener() {
+            public void onProgress(Object item, int action, int progress) {
+            }
+        });
+
+        try {
+            final int[] progressUpdate = new int[100];
+            mVideoEditor.export(outFilename, MediaProperties.HEIGHT_720,
+                MediaProperties.BITRATE_800K, new ExportProgressListener() {
+                    int i = 0;
+                    public void onProgress(VideoEditor ve, String outFileName,
+                        int progress) {
+                            progressUpdate[i++] = progress;
+                    }
+                });
+            mVideoEditorHelper.checkProgressCBValues(progressUpdate);
+        } catch (Exception e) {
+            assertTrue("Error in Export" + e.toString(), false);
+        }
+        mVideoEditorHelper.validateExport(mVideoEditor, outFilename,
+            MediaProperties.HEIGHT_720, 0, (mediaVideoItem.getTimelineDuration() +
+            mediaImageItem.getDuration()),
+            MediaProperties.VCODEC_H264BP, MediaProperties.ACODEC_AAC_LC);
+
+        mVideoEditorHelper.checkDeleteExistingFile(outFilename);
+    }
+
+    /**
+     *To Test export : With Transition on Different Media Items
+     */
+    // TODO :remove TC_EXP_005
+    @LargeTest
+    public void testExportTransition() throws Exception {
+        final String videoItemFilename1 = INPUT_FILE_PATH
+            + "H263_profile0_176x144_15fps_256kbps_AACLC_32kHz_128kbps_s_0_26.3gp";
+        final String imageItemFilename1 = INPUT_FILE_PATH + "IMG_1600x1200.jpg";
+        final String videoItemFilename2 = INPUT_FILE_PATH
+            + "H264_BP_640x480_12.5fps_256kbps_AACLC_16khz_24kbps_s_0_26.mp4";
+        final String videoItemFilename3 = INPUT_FILE_PATH +
+            "MPEG4_SP_720x480_30fps_280kbps_AACLC_48kHz_96kbps_s_0_21.mp4";
+
+        final String imageItemFilename2 = INPUT_FILE_PATH + "IMG_176x144.jpg";
+        final String imageItemFilename3 = INPUT_FILE_PATH + "IMG_640x480.jpg";
+        final String outFilename = mVideoEditorHelper
+            .createRandomFile(mVideoEditor.getPath() + "/") + ".3gp";
+        final String maskFilename = INPUT_FILE_PATH +
+            "TransitionSpiral_QVGA.jpg";
+
+        final MediaVideoItem mediaItem1 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
+                videoItemFilename1, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mediaItem1.setExtractBoundaries(2000, 7000);
+        mVideoEditor.addMediaItem(mediaItem1);
+
+        final TransitionAlpha transition1 =
+            mVideoEditorHelper.createTAlpha("transition1", null, mediaItem1,
+                2000, Transition.BEHAVIOR_LINEAR, maskFilename, 50, true);
+        mVideoEditor.addTransition(transition1);
+
+        final MediaImageItem mediaItem2 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m2",
+                imageItemFilename1, 8000, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mVideoEditor.addMediaItem(mediaItem2);
+
+        final MediaVideoItem mediaItem3 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m3",
+                videoItemFilename2, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mediaItem3.setExtractBoundaries(0, 8000);
+        mVideoEditor.addMediaItem(mediaItem3);
+
+        final TransitionSliding transition2And3 =
+            mVideoEditorHelper.createTSliding("transition2", mediaItem2,
+                mediaItem3, 4000, Transition.BEHAVIOR_MIDDLE_FAST,
+                TransitionSliding.DIRECTION_RIGHT_OUT_LEFT_IN);
+        mVideoEditor.addTransition(transition2And3);
+
+        final MediaVideoItem mediaItem4 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m4",
+                videoItemFilename3, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mVideoEditor.addMediaItem(mediaItem4);
+        mediaItem4.setExtractBoundaries(0, 8000);
+
+        final TransitionCrossfade transition3And4 =
+            mVideoEditorHelper.createTCrossFade("transition3", mediaItem3,
+                mediaItem4, 3500, Transition.BEHAVIOR_MIDDLE_SLOW);
+        mVideoEditor.addTransition(transition3And4);
+
+        final MediaImageItem mediaItem5 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m5",
+                imageItemFilename2, 7000, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mVideoEditor.addMediaItem(mediaItem5);
+
+        final TransitionFadeBlack transition4And5 =
+            mVideoEditorHelper.createTFadeBlack("transition4", mediaItem4,
+                mediaItem5, 3500, Transition.BEHAVIOR_SPEED_DOWN);
+        mVideoEditor.addTransition(transition4And5);
+
+        final MediaImageItem mediaItem6 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m6",
+                imageItemFilename3, 3000, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mVideoEditor.addMediaItem(mediaItem6);
+
+        final TransitionSliding transition5And6 =
+            mVideoEditorHelper.createTSliding("transition5", mediaItem5,
+                mediaItem6, 1000/*4000*/, Transition.BEHAVIOR_SPEED_UP,
+                TransitionSliding.DIRECTION_LEFT_OUT_RIGHT_IN);
+        mVideoEditor.addTransition(transition5And6);
+
+        final TransitionSliding transition6 =
+            mVideoEditorHelper.createTSliding("transition6", mediaItem6, null,
+                1000 /*4000*/, Transition.BEHAVIOR_SPEED_UP,
+                TransitionSliding.DIRECTION_TOP_OUT_BOTTOM_IN);
+        mVideoEditor.addTransition(transition6);
+
+        mVideoEditor.generatePreview(new MediaProcessingProgressListener() {
+            public void onProgress(Object item, int action, int progress) {
+            }
+        });
+
+        try {
+            final int[] progressUpdate = new int[100];
+            mVideoEditor.export(outFilename, MediaProperties.HEIGHT_720,
+                MediaProperties.BITRATE_800K, new ExportProgressListener() {
+                    int i = 0;
+                    public void onProgress(VideoEditor ve, String outFileName,
+                        int progress) {
+                            progressUpdate[i++] = progress;
+                    }
+                });
+            mVideoEditorHelper.checkProgressCBValues(progressUpdate);
+        } catch (Exception e) {
+            assertTrue("Error in Export" + e.toString(), false);
+        }
+        final long storyBoardDuration = mediaItem1.getTimelineDuration()
+            + mediaItem2.getTimelineDuration()
+            + mediaItem3.getTimelineDuration() - transition2And3.getDuration()
+            + mediaItem4.getTimelineDuration() - transition3And4.getDuration()
+            + mediaItem5.getTimelineDuration() - transition4And5.getDuration()
+            + mediaItem6.getTimelineDuration() - transition5And6.getDuration();
+        mVideoEditorHelper.validateExport(mVideoEditor, outFilename,
+            MediaProperties.HEIGHT_720, 0, storyBoardDuration,
+            MediaProperties.VCODEC_H264BP, MediaProperties.ACODEC_AAC_LC);
+        mVideoEditorHelper.checkDeleteExistingFile(outFilename);
+    }
+
+    /**
+     * To Test Export : Without any Media Items in the story Board
+     *
+     * @throws Exception
+     */
+    // TODO :remove TC_EXP_006
+    @LargeTest
+    public void testExportWithoutMediaItems() throws Exception {
+        boolean flagForException = false;
+        try {
+            final int[] progressUpdate = new int[100];
+            mVideoEditor.export("/sdcard/Test.3gp", MediaProperties.HEIGHT_720,
+                MediaProperties.BITRATE_800K, new ExportProgressListener() {
+                    int i = 0;
+                    public void onProgress(VideoEditor ve, String outFileName,
+                        int progress) {
+                            progressUpdate[i++] = progress;
+                    }
+                });
+            mVideoEditorHelper.checkProgressCBValues(progressUpdate);
+        } catch (IllegalStateException e) {
+            flagForException = true;
+        }
+        assertTrue("Export without any MediaItems", flagForException);
+    }
+
+    /**
+     * To Test Export : With Media Items add and removed in the story Board
+     *
+     * @throws Exception
+     */
+    // TODO :remove TC_EXP_007
+    @LargeTest
+    public void testExportWithoutMediaItemsAddRemove() throws Exception {
+        final String videoItemFilename1 = INPUT_FILE_PATH +
+            "H263_profile0_176x144_15fps_256kbps_AACLC_32kHz_128kbps_s_1_17.3gp";
+        final String imageItemFilename1 = INPUT_FILE_PATH + "IMG_640x480.jpg";
+        final String maskFilename = INPUT_FILE_PATH + "TransitionSpiral_QVGA.jpg";
+        boolean flagForException = false;
+
+        final MediaVideoItem mediaItem1 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
+                videoItemFilename1, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mediaItem1.setExtractBoundaries(0, 15000);
+        mVideoEditor.addMediaItem(mediaItem1);
+
+        final MediaImageItem mediaItem2 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m2",
+                imageItemFilename1, 15000,
+                MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mVideoEditor.addMediaItem(mediaItem2);
+
+        final TransitionAlpha transition1 =
+            mVideoEditorHelper.createTAlpha("transition1", mediaItem1, mediaItem2,
+                3000, Transition.BEHAVIOR_LINEAR, maskFilename, 50, false);
+        mVideoEditor.addTransition(transition1);
+
+        final EffectColor effectColor =
+            mVideoEditorHelper.createEffectItem(mediaItem2, "effect", 12000,
+                3000, EffectColor.TYPE_COLOR, EffectColor.PINK);
+        mediaItem2.addEffect(effectColor);
+
+        mVideoEditor.removeMediaItem(mediaItem1.getId());
+        mVideoEditor.removeMediaItem(mediaItem2.getId());
+        try {
+            final int[] progressUpdate = new int[100];
+            mVideoEditor.export("/sdcard/Test.3gp", MediaProperties.HEIGHT_720,
+                MediaProperties.BITRATE_800K, new ExportProgressListener() {
+                    int i = 0;
+                    public void onProgress(VideoEditor ve, String outFileName,
+                        int progress) {
+                            progressUpdate[i++] = progress;
+                    }
+                });
+            mVideoEditorHelper.checkProgressCBValues(progressUpdate);
+        } catch (IllegalStateException e) {
+            flagForException = true;
+        }
+        assertTrue("Export with MediaItem added and removed", flagForException);
+    }
+
+    /**
+     * To Test Export : With Video and Image : MMS use case
+     *
+     * @throws Exception
+     */
+    // TODO :remove TC_EXP_008
+    @LargeTest
+    public void testExportMMS() throws Exception {
+        final String videoItemFilename1 = INPUT_FILE_PATH
+            + "H263_profile0_176x144_15fps_256kbps_AACLC_32kHz_128kbps_s_1_17.3gp";
+        final String imageItemFilename1 = INPUT_FILE_PATH + "IMG_1600x1200.jpg";
+        final String videoItemFilename2 = INPUT_FILE_PATH
+            + "H264_BP_640x480_12.5fps_256kbps_AACLC_16khz_24kbps_s_0_26.mp4";
+        final String maskFilename = INPUT_FILE_PATH + "TransitionSpiral_QVGA.jpg";
+        final String outFilename = mVideoEditorHelper
+            .createRandomFile(mVideoEditor.getPath() + "/") + ".3gp";
+
+        final MediaVideoItem mediaItem1 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
+                videoItemFilename1, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mediaItem1.setExtractBoundaries(2000, 7000);
+        mVideoEditor.addMediaItem(mediaItem1);
+
+        final TransitionAlpha transition1 =
+            mVideoEditorHelper.createTAlpha("transition1", null, mediaItem1,
+                2000, Transition.BEHAVIOR_LINEAR, maskFilename, 50, true);
+        mVideoEditor.addTransition(transition1);
+
+        final MediaImageItem mediaItem2 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m2",
+                imageItemFilename1, 8000, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mVideoEditor.addMediaItem(mediaItem2);
+
+        final MediaVideoItem mediaItem3 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m3",
+                videoItemFilename2, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mediaItem3.setExtractBoundaries(0, 8000);
+        mVideoEditor.addMediaItem(mediaItem3);
+
+        final TransitionSliding transition2And3 =
+            mVideoEditorHelper.createTSliding("transition2", mediaItem2,
+                mediaItem3, 4000, Transition.BEHAVIOR_MIDDLE_FAST,
+                TransitionSliding.DIRECTION_RIGHT_OUT_LEFT_IN);
+        mVideoEditor.addTransition(transition2And3);
+
+        final TransitionCrossfade transition3 =
+            mVideoEditorHelper.createTCrossFade("transition3", mediaItem3, null,
+                3500, Transition.BEHAVIOR_MIDDLE_SLOW);
+        mVideoEditor.addTransition(transition3);
+
+        final EffectColor effectColor =
+            mVideoEditorHelper.createEffectItem(mediaItem2, "effect", 0,
+                3000, EffectColor.TYPE_COLOR, EffectColor.PINK);
+        mediaItem2.addEffect(effectColor);
+
+        mVideoEditor.setAspectRatio(MediaProperties.ASPECT_RATIO_11_9);
+
+        try {
+            final int[] progressUpdate = new int[100];
+            mVideoEditor.export(outFilename, MediaProperties.HEIGHT_144,
+                MediaProperties.BITRATE_800K, new ExportProgressListener() {
+                    int i = 0;
+                    public void onProgress(VideoEditor ve, String outFileName,
+                        int progress) {
+                            progressUpdate[i++] = progress;
+                    }
+                });
+            mVideoEditorHelper.checkProgressCBValues(progressUpdate);
+        } catch (Exception e) {
+            assertTrue("Error in Export" + e.toString(), false);
+        }
+        final long storyBoardDuration = mediaItem1.getTimelineDuration()
+            - transition1.getDuration() + mediaItem2.getTimelineDuration()
+            + mediaItem3.getTimelineDuration() - transition2And3.getDuration()
+            - transition3.getDuration();
+
+        mVideoEditorHelper.validateExport(mVideoEditor, outFilename,
+            MediaProperties.HEIGHT_144, 0, storyBoardDuration,
+            MediaProperties.VCODEC_H264BP, MediaProperties.ACODEC_AAC_LC);
+         mVideoEditorHelper.checkDeleteExistingFile(outFilename);
+    }
+
+    /**
+     * To Test Export :Media Item having duration of 1 Hour
+     *
+     * @throws Exception
+     */
+    @LargeTest
+    public void testExportDuration1Hour() throws Exception {
+        final String videoItemFilename1 = INPUT_FILE_PATH +
+            "H264_BP_640x480_15fps_384kbps_60_0.mp4";
+        final String outFilename = mVideoEditorHelper.createRandomFile(
+            mVideoEditor.getPath() + "/") + ".3gp";
+
+        final MediaVideoItem mediaItem1 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
+                videoItemFilename1, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mVideoEditor.addMediaItem(mediaItem1);
+        try {
+            final int[] progressUpdate = new int[100];
+            mVideoEditor.export(outFilename, MediaProperties.HEIGHT_144,
+                MediaProperties.BITRATE_800K, new ExportProgressListener() {
+                    int i = 0;
+                    public void onProgress(VideoEditor ve, String outFileName,
+                        int progress) {
+                            progressUpdate[i++] = progress;
+                    }
+                });
+            mVideoEditorHelper.checkProgressCBValues(progressUpdate);
+        }catch (Exception e) {
+            assertTrue("Error in Export" + e.toString(), false);
+        }
+        mVideoEditorHelper.validateExport(mVideoEditor, outFilename,
+            MediaProperties.HEIGHT_720, 0, mediaItem1.getDuration(),
+            MediaProperties.VCODEC_H264BP, MediaProperties.ACODEC_AAC_LC);
+        mVideoEditorHelper.checkDeleteExistingFile(outFilename);
+    }
+
+    /**
+     * To Test Export : Storage location having very less space (Less than 100
+     * KB)
+     *
+     * @throws Exception
+     */
+    @LargeTest
+    public void testExportWithStorageFull() throws Exception {
+        final String videoItemFilename1 = INPUT_FILE_PATH
+            + "H264_BP_640x480_12.5fps_256kbps_AACLC_16khz_24kbps_s_0_26.mp4";
+        final String outFilename = mVideoEditorHelper
+            .createRandomFile(mVideoEditor.getPath() + "/") + ".3gp";
+        boolean flagForException = false;
+
+        mVideoEditorHelper.createMediaItem(mVideoEditor, "m1", videoItemFilename1,
+            MediaItem.RENDERING_MODE_BLACK_BORDER);
+        try {
+            final int[] progressUpdate = new int[100];
+            mVideoEditor.export(outFilename, MediaProperties.HEIGHT_144,
+                MediaProperties.BITRATE_800K, new ExportProgressListener() {
+                    int i = 0;
+                    public void onProgress(VideoEditor ve, String outFileName,
+                        int progress) {
+                            progressUpdate[i++] = progress;
+                    }
+                });
+            mVideoEditorHelper.checkProgressCBValues(progressUpdate);
+        } catch (Exception e) {
+            flagForException = true;
+        }
+        assertTrue("Error in exporting file due to lack of storage space",
+            flagForException);
+    }
+
+     /**
+     * To Test Export :Two Media Items added
+     *
+     * @throws Exception
+     */
+    @LargeTest
+    public void testExportTwoVideos() throws Exception {
+        final String videoItemFileName = INPUT_FILE_PATH
+            + "H263_profile0_176x144_15fps_256kbps_AACLC_32kHz_128kbps_s_1_17.3gp";
+        final String videoItemFileName1 = INPUT_FILE_PATH +
+            "H264_BP_640x480_12.5fps_256kbps_AACLC_16khz_24kbps_s_0_26.mp4";
+        final String outFilename = mVideoEditorHelper
+            .createRandomFile(mVideoEditor.getPath() + "/") + ".3gp";
+
+        final MediaVideoItem mediaVideoItem =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
+                videoItemFileName, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mVideoEditor.addMediaItem(mediaVideoItem);
+
+        final MediaVideoItem mediaVideoItem1 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m2",
+                videoItemFileName1, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mVideoEditor.addMediaItem(mediaVideoItem1);
+
+        mVideoEditor.generatePreview(new MediaProcessingProgressListener() {
+            public void onProgress(Object item, int action, int progress) {
+            }
+        });
+
+        try {
+            final int[] progressUpdate = new int[100];
+            mVideoEditor.export(outFilename, MediaProperties.HEIGHT_720,
+                MediaProperties.BITRATE_800K, new ExportProgressListener() {
+                    int i = 0;
+                    public void onProgress(VideoEditor ve, String outFileName,
+                        int progress) {
+                            progressUpdate[i++] = progress;
+                    }
+                });
+            mVideoEditorHelper.checkProgressCBValues(progressUpdate);
+        } catch (Exception e) {
+            assertTrue("Error in Export" + e.toString(), false);
+        }
+        mVideoEditorHelper.validateExport(mVideoEditor, outFilename,
+            MediaProperties.HEIGHT_720, 0,
+            (mediaVideoItem.getDuration()+ mediaVideoItem1.getDuration()),
+            MediaProperties.VCODEC_H264BP, MediaProperties.ACODEC_AAC_LC);
+        mVideoEditorHelper.checkDeleteExistingFile(outFilename);
+    }
+}
diff --git a/media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/functional/VideoEditorPreviewTest.java b/media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/functional/VideoEditorPreviewTest.java
new file mode 100755
index 0000000..f0d4651
--- /dev/null
+++ b/media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/functional/VideoEditorPreviewTest.java
@@ -0,0 +1,990 @@
+/*
+ * Copyright (C) 2011 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.
+ */
+
+package com.android.mediaframeworktest.functional;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.List;
+import java.util.concurrent.Semaphore;
+
+import android.graphics.Bitmap;
+import android.graphics.Rect;
+import android.media.videoeditor.AudioTrack;
+import android.media.videoeditor.Effect;
+import android.media.videoeditor.EffectColor;
+import android.media.videoeditor.EffectKenBurns;
+import android.media.videoeditor.MediaImageItem;
+import android.media.videoeditor.MediaItem;
+import android.media.videoeditor.MediaProperties;
+import android.media.videoeditor.MediaVideoItem;
+import android.media.videoeditor.Overlay;
+import android.media.videoeditor.OverlayFrame;
+import android.media.videoeditor.Transition;
+import android.media.videoeditor.TransitionAlpha;
+import android.media.videoeditor.TransitionCrossfade;
+import android.media.videoeditor.TransitionFadeBlack;
+import android.media.videoeditor.TransitionSliding;
+import android.media.videoeditor.VideoEditor;
+import android.media.videoeditor.VideoEditor.ExportProgressListener;
+import android.media.videoeditor.VideoEditor.MediaProcessingProgressListener;
+import android.media.videoeditor.VideoEditor.PreviewProgressListener;
+import android.os.Environment;
+import android.test.ActivityInstrumentationTestCase;
+import android.view.SurfaceHolder;
+
+import com.android.mediaframeworktest.MediaFrameworkTest;
+import android.test.suitebuilder.annotation.LargeTest;
+import com.android.mediaframeworktest.VideoEditorHelper;
+
+
+import android.util.Log;
+
+public class VideoEditorPreviewTest extends
+    ActivityInstrumentationTestCase<MediaFrameworkTest> {
+    private final String TAG = "VideoEditorTest";
+
+    private final String PROJECT_LOCATION = VideoEditorHelper.PROJECT_LOCATION_COMMON;
+
+    private final String INPUT_FILE_PATH = VideoEditorHelper.INPUT_FILE_PATH_COMMON;
+
+    private final String PROJECT_CLASS_NAME =
+        "android.media.videoeditor.VideoEditorImpl";
+
+    private VideoEditor mVideoEditor;
+
+    private VideoEditorHelper mVideoEditorHelper;
+
+    // Declares the annotation for Preview Test Cases
+    public @interface Preview {
+    }
+
+    public VideoEditorPreviewTest() {
+        super("com.android.mediaframeworktest", MediaFrameworkTest.class);
+    }
+
+    @Override
+    protected void setUp() throws Exception {
+        // setup for each test case.
+        super.setUp();
+        mVideoEditorHelper = new VideoEditorHelper();
+        // Create a random String which will be used as project path, where all
+        // project related files will be stored.
+        final String projectPath =
+            mVideoEditorHelper.createRandomFile(PROJECT_LOCATION);
+        mVideoEditor = mVideoEditorHelper.createVideoEditor(projectPath);
+    }
+
+    @Override
+    protected void tearDown() throws Exception {
+        mVideoEditorHelper.destroyVideoEditor(mVideoEditor);
+        // Clean the directory created as project path
+        mVideoEditorHelper.deleteProject(new File(mVideoEditor.getPath()));
+        System.gc();
+        super.tearDown();
+    }
+
+    protected void validatePreviewProgress(int startMs, int endMs, boolean loop, long duration) throws Exception {
+
+        final int[] progressUpdate = new int[100];
+        final Semaphore blockTillPreviewCompletes = new Semaphore(1);
+        final long mDuration = duration;
+
+        mVideoEditor.generatePreview(new MediaProcessingProgressListener() {
+            int i = 0;
+            public void onProgress(Object item, int action, int progress) {
+                progressUpdate[i++] = progress;
+            }
+        });
+        mVideoEditorHelper.checkProgressCBValues(progressUpdate);
+        final SurfaceHolder surfaceHolder =
+            MediaFrameworkTest.mSurfaceView.getHolder();
+
+        blockTillPreviewCompletes.acquire();
+        try {
+        mVideoEditor.startPreview(surfaceHolder, startMs, endMs, loop, 1,
+            new PreviewProgressListener() {
+                public void onProgress(VideoEditor videoEditor, long timeMs,
+                    boolean end) {
+                        if ((mDuration != 0) && (timeMs >= mDuration)) {
+                            blockTillPreviewCompletes.release();
+                        }
+                        else if (end == true) {
+                            blockTillPreviewCompletes.release();
+                        }
+                    }
+        });
+        } catch (Exception e) {
+            Log.e("VideoEditorPreviewTest","Exception thrown during preview");
+            blockTillPreviewCompletes.release();
+        }
+        blockTillPreviewCompletes.acquire();
+        mVideoEditor.stopPreview();
+        blockTillPreviewCompletes.release();
+    }
+
+    // -----------------------------------------------------------------
+    // Preview
+    // -----------------------------------------------------------------
+
+    /**
+     *To test Preview : FULL Preview of current work (beginning till end)
+     */
+    // TODO : remove TC_PRV_001
+    @LargeTest
+    public void testPreviewTheStoryBoard() throws Exception {
+        final String videoItemFileName1 = INPUT_FILE_PATH
+            + "MPEG4_SP_720x480_30fps_280kbps_AACLC_48kHz_96kbps_s_0_21.mp4";
+        final String videoItemFileName2 = INPUT_FILE_PATH
+            + "MPEG4_SP_640x480_15fps_256kbps_0_30.mp4";
+        final String videoItemFileName3 = INPUT_FILE_PATH
+            + "H263_profile0_176x144_15fps_256kbps_AACLC_32kHz_128kbps_s_1_17.3gp";
+
+        final MediaVideoItem mediaVideoItem1 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "mediaVideoItem1",
+                videoItemFileName1, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mediaVideoItem1.setExtractBoundaries(0, 10000);
+        mVideoEditor.addMediaItem(mediaVideoItem1);
+
+        final MediaVideoItem mediaVideoItem2 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "mediaVideoItem2",
+                videoItemFileName2, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mVideoEditor.addMediaItem(mediaVideoItem2);
+        mediaVideoItem2.setExtractBoundaries(0, 10000);
+
+        final MediaVideoItem mediaVideoItem3 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "mediaVideoItem3",
+                videoItemFileName3, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mediaVideoItem3.setExtractBoundaries(0, 10000);
+
+        mVideoEditor.insertMediaItem(mediaVideoItem3, mediaVideoItem1.getId());
+        List<MediaItem> mediaList = mVideoEditor.getAllMediaItems();
+        assertEquals("Media Item 1", mediaVideoItem1, mediaList.get(0));
+        assertEquals("Media Item 3", mediaVideoItem3, mediaList.get(1));
+        assertEquals("Media Item 2", mediaVideoItem2, mediaList.get(2));
+
+        mediaVideoItem1.setRenderingMode(MediaItem.RENDERING_MODE_BLACK_BORDER);
+        assertEquals("Media Item 1 Rendering Mode",
+            MediaItem.RENDERING_MODE_BLACK_BORDER,
+            mediaVideoItem1.getRenderingMode());
+
+        mediaVideoItem2.setRenderingMode(MediaItem.RENDERING_MODE_BLACK_BORDER);
+        assertEquals("Media Item 2 Rendering Mode",
+            MediaItem.RENDERING_MODE_BLACK_BORDER,
+            mediaVideoItem2.getRenderingMode());
+
+        mediaVideoItem3.setRenderingMode(MediaItem.RENDERING_MODE_STRETCH);
+        assertEquals("Media Item 3 Rendering Mode",
+            MediaItem.RENDERING_MODE_STRETCH,
+            mediaVideoItem3.getRenderingMode());
+
+        mVideoEditor.setAspectRatio(MediaProperties.ASPECT_RATIO_5_3);
+        assertEquals("Aspect Ratio", MediaProperties.ASPECT_RATIO_5_3,
+            mVideoEditor.getAspectRatio());
+
+        validatePreviewProgress(0, -1, false, 0);
+    }
+
+    /**
+     * To test Preview : Preview of start + 10 sec till end of story board
+     */
+    // TODO : remove TC_PRV_002
+    @LargeTest
+    public void testPreviewTheStoryBoardFromDuration() throws Exception {
+        final String videoItemFileName1 = INPUT_FILE_PATH
+            + "MPEG4_SP_720x480_30fps_280kbps_AACLC_48kHz_96kbps_s_0_21.mp4";
+        final String videoItemFileName2 = INPUT_FILE_PATH +
+            "MPEG4_SP_640x480_15fps_256kbps_0_30.mp4";
+        final String videoItemFileName3 = INPUT_FILE_PATH
+            + "H263_profile0_176x144_15fps_256kbps_AACLC_32kHz_128kbps_s_1_17.3gp";
+        final Semaphore blockTillPreviewCompletes = new Semaphore(1);
+
+        final MediaVideoItem mediaVideoItem1 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "mediaVideoItem1",
+                videoItemFileName1, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mediaVideoItem1.setExtractBoundaries(0, 10000);
+        mVideoEditor.addMediaItem(mediaVideoItem1);
+
+        final MediaVideoItem mediaVideoItem2 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "mediaVideoItem2",
+                videoItemFileName2, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mediaVideoItem2.setExtractBoundaries(0, 10000);
+        mVideoEditor.addMediaItem(mediaVideoItem2);
+
+        final MediaVideoItem mediaVideoItem3 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "mediaVideoItem3",
+                videoItemFileName3, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mediaVideoItem3.setExtractBoundaries(0, 10000);
+
+        mVideoEditor.insertMediaItem(mediaVideoItem3, mediaVideoItem1.getId());
+
+        List<MediaItem> mediaList = mVideoEditor.getAllMediaItems();
+        assertEquals("Media Item 1", mediaVideoItem1, mediaList.get(0));
+        assertEquals("Media Item 3", mediaVideoItem3, mediaList.get(1));
+        assertEquals("Media Item 2", mediaVideoItem2, mediaList.get(2));
+        mediaVideoItem1.setRenderingMode(MediaItem.RENDERING_MODE_BLACK_BORDER);
+
+        assertEquals("Media Item 1 Rendering Mode",
+            MediaItem.RENDERING_MODE_BLACK_BORDER,
+            mediaVideoItem1.getRenderingMode());
+        mediaVideoItem2.setRenderingMode(MediaItem.RENDERING_MODE_BLACK_BORDER);
+
+        assertEquals("Media Item 2 Rendering Mode",
+            MediaItem.RENDERING_MODE_BLACK_BORDER,
+            mediaVideoItem2.getRenderingMode());
+        mediaVideoItem3.setRenderingMode(MediaItem.RENDERING_MODE_STRETCH);
+
+        assertEquals("Media Item 3 Rendering Mode",
+            MediaItem.RENDERING_MODE_STRETCH,
+            mediaVideoItem3.getRenderingMode());
+
+        mVideoEditor.setAspectRatio(MediaProperties.ASPECT_RATIO_5_3);
+        assertEquals("Aspect Ratio", MediaProperties.ASPECT_RATIO_5_3,
+            mVideoEditor.getAspectRatio());
+
+        validatePreviewProgress(10000, -1, false, 0);
+    }
+
+    /**
+     * To test Preview : Preview of current Effects applied
+     */
+    // TODO : remove TC_PRV_003
+    @LargeTest
+    public void testPreviewOfEffects() throws Exception {
+        final String videoItemFileName1 = INPUT_FILE_PATH +
+            "H264_BP_640x480_30fps_256kbps_1_17.mp4";
+
+        final Semaphore blockTillPreviewCompletes = new Semaphore(1);
+
+        final MediaVideoItem mediaVideoItem1 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "mediaVideoItem1",
+                videoItemFileName1, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mVideoEditor.addMediaItem(mediaVideoItem1);
+
+        final EffectColor effectNegative =
+            mVideoEditorHelper.createEffectItem(mediaVideoItem1,
+                "effectNegative", 0, 2000, EffectColor.TYPE_NEGATIVE, 0);
+        mediaVideoItem1.addEffect(effectNegative);
+
+        final EffectColor effectGreen =
+            mVideoEditorHelper.createEffectItem(mediaVideoItem1, "effectGreen",
+                2000, 3000, EffectColor.TYPE_COLOR, EffectColor.GREEN);
+        mediaVideoItem1.addEffect(effectGreen);
+
+        final EffectColor effectFifties =
+            mVideoEditorHelper.createEffectItem(mediaVideoItem1,
+                "effectFifties", 5000, 4000, EffectColor.TYPE_FIFTIES, 0);
+        mediaVideoItem1.addEffect(effectFifties);
+
+        List<Effect> effectList = mediaVideoItem1.getAllEffects();
+        assertEquals("Effect List Size", 3, effectList.size());
+        assertEquals("Effect negative", effectNegative, effectList.get(0));
+        assertEquals("Effect Green", effectGreen, effectList.get(1));
+        assertEquals("Effect Fifties", effectFifties, effectList.get(2));
+
+        mVideoEditor.setAspectRatio(MediaProperties.ASPECT_RATIO_4_3);
+        assertEquals("Aspect Ratio", MediaProperties.ASPECT_RATIO_4_3,
+            mVideoEditor.getAspectRatio());
+
+        final long storyboardDuration = mVideoEditor.getDuration() / 2;
+        validatePreviewProgress(0, -1, false, storyboardDuration);
+
+        assertEquals("Removing Effect : Negative", effectNegative,
+            mediaVideoItem1.removeEffect(effectNegative.getId()));
+
+        effectList = mediaVideoItem1.getAllEffects();
+
+        assertEquals("Effect List Size", 2, effectList.size());
+        assertEquals("Effect Green", effectGreen, effectList.get(0));
+        assertEquals("Effect Fifties", effectFifties, effectList.get(1));
+
+        validatePreviewProgress(0, -1, false, 0);
+    }
+
+    /**
+     *To test Preview : Preview of current Transitions applied (with multiple
+     * generatePreview)
+     */
+    // TODO : remove TC_PRV_004
+    @LargeTest
+    public void testPreviewWithTransition() throws Exception {
+
+        final String videoItemFileName1 = INPUT_FILE_PATH +
+            "H263_profile0_176x144_10fps_96kbps_0_25.3gp";
+        final String imageItemFileName1 = INPUT_FILE_PATH +
+            "IMG_1600x1200.jpg";
+        final String videoItemFileName2 = INPUT_FILE_PATH +
+            "MPEG4_SP_800x480_515kbps_15fps_AMR_NB_8KHz_12.2kbps_m_0_26.mp4";
+        final String maskFilename = INPUT_FILE_PATH +
+            "TransitionSpiral_QVGA.jpg";
+
+        final Semaphore blockTillPreviewCompletes = new Semaphore(1);
+
+        final MediaVideoItem mediaVideoItem1 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
+                videoItemFileName1, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mediaVideoItem1.setExtractBoundaries(0, 10000);
+        mVideoEditor.addMediaItem(mediaVideoItem1);
+
+        final MediaImageItem mediaImageItem1 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m2",
+                imageItemFileName1, 10000, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mVideoEditor.addMediaItem(mediaImageItem1);
+
+        final MediaVideoItem mediaVideoItem2 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m3",
+                videoItemFileName2, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mediaVideoItem2.setExtractBoundaries(0, 10000);
+        mVideoEditor.addMediaItem(mediaVideoItem2);
+
+        final TransitionCrossfade transition1And2CrossFade =
+            mVideoEditorHelper.createTCrossFade("transition_1_2_CF",
+                mediaVideoItem1, mediaImageItem1, 2000,
+                Transition.BEHAVIOR_MIDDLE_FAST);
+        mVideoEditor.addTransition(transition1And2CrossFade);
+
+        final TransitionAlpha transition2And3Alpha =
+            mVideoEditorHelper.createTAlpha("transition_2_3", mediaImageItem1,
+                mediaVideoItem2, 4000, Transition.BEHAVIOR_SPEED_UP,
+                maskFilename, 50, true);
+        mVideoEditor.addTransition(transition2And3Alpha);
+
+        final TransitionFadeBlack transition1FadeBlack =
+            mVideoEditorHelper.createTFadeBlack("transition_1FB", null,
+                mediaVideoItem1, 2000, Transition.BEHAVIOR_MIDDLE_FAST);
+        mVideoEditor.addTransition(transition1FadeBlack);
+
+        List<Transition> transitionList = mVideoEditor.getAllTransitions();
+        assertEquals("Transition List Size", 3, transitionList.size());
+        assertEquals("Transition 1", transition1And2CrossFade,
+            transitionList.get(0));
+        assertEquals("Transition 2", transition2And3Alpha, transitionList.get(1));
+        assertEquals("Transition 3", transition1FadeBlack, transitionList.get(2));
+
+        mVideoEditor.setAspectRatio(MediaProperties.ASPECT_RATIO_3_2);
+
+        final int[] progressValues = new int[305];
+        mVideoEditor.generatePreview(new MediaProcessingProgressListener() {
+            int i = 0;
+
+            public void onProgress(Object item, int action, int progress) {
+                if (item instanceof TransitionCrossfade) {
+                    progressValues[i] = progress;
+                    assertEquals("Object", item, transition1And2CrossFade);
+                    assertEquals("Action", action,
+                        MediaProcessingProgressListener.ACTION_ENCODE);
+                } else if (item instanceof TransitionAlpha) {
+                    progressValues[i] = progress;
+                    assertEquals("Object", item, transition2And3Alpha);
+                    assertEquals("Action", action,
+                        MediaProcessingProgressListener.ACTION_ENCODE);
+                } else if (item instanceof TransitionFadeBlack) {
+                    progressValues[i] = progress;
+                    assertEquals("Object", item, transition1FadeBlack);
+                    assertEquals("Action", action,
+                        MediaProcessingProgressListener.ACTION_ENCODE);
+                }
+                i++;
+            }
+        });
+
+        mVideoEditorHelper.checkProgressCBValues(progressValues);
+        final SurfaceHolder surfaceHolder =
+            MediaFrameworkTest.mSurfaceView.getHolder();
+        blockTillPreviewCompletes.acquire();
+        mVideoEditor.startPreview(surfaceHolder, 0, -1, false, 1,
+            new PreviewProgressListener() {
+            public void onProgress(VideoEditor videoEditor, long timeMs,
+                boolean end) {
+                if (timeMs >= 10000) {
+                    blockTillPreviewCompletes.release();
+                }
+            }
+        });
+        blockTillPreviewCompletes.acquire();
+        mVideoEditor.stopPreview();
+        blockTillPreviewCompletes.release();
+
+        assertEquals("Removing Transition " + transition1And2CrossFade.getId(),
+            transition1And2CrossFade,
+            mVideoEditor.removeTransition(transition1And2CrossFade.getId()));
+        transitionList = mVideoEditor.getAllTransitions();
+        assertEquals("Transition List Size", 2, transitionList.size());
+        assertEquals("Transition 1", transition2And3Alpha, transitionList.get(0));
+        assertEquals("Transition 2", transition1FadeBlack, transitionList.get(1));
+
+        validatePreviewProgress(0, -1, false, 25000);
+
+        mVideoEditorHelper.checkProgressCBValues(progressValues);
+        final TransitionSliding transition1And2Sliding =
+            mVideoEditorHelper.createTSliding("transition_1_2Sliding",
+                mediaVideoItem1, mediaImageItem1, 4000,
+                Transition.BEHAVIOR_MIDDLE_FAST,
+                TransitionSliding.DIRECTION_LEFT_OUT_RIGHT_IN);
+        mVideoEditor.addTransition(transition1And2Sliding);
+
+        transitionList = mVideoEditor.getAllTransitions();
+        assertEquals("Transition List Size", 3, transitionList.size());
+        assertEquals("Transition 1", transition2And3Alpha, transitionList.get(0));
+        assertEquals("Transition 2", transition1FadeBlack, transitionList.get(1));
+        assertEquals("Transition 3", transition1And2Sliding,
+            transitionList.get(2));
+
+        validatePreviewProgress(5000, -1, false, 0);
+    }
+
+    /**
+     * To test Preview : Preview of current Overlay applied
+     */
+    // TODO : remove TC_PRV_005
+    @LargeTest
+    public void testPreviewWithOverlay() throws Exception {
+        final String videoItemFileName = INPUT_FILE_PATH
+            + "MPEG4_SP_640x480_15fps_1200kbps_AACLC_48khz_64kbps_m_1_17.3gp";
+        final String overlayFilename1 = INPUT_FILE_PATH +
+            "IMG_640x480_Overlay1.png";
+        final String overlayFilename2 = INPUT_FILE_PATH +
+            "IMG_640x480_Overlay2.png";
+        final int previewFrom = 5000;
+        final int previewTo = 10000;
+        final boolean previewLoop = false;
+        final int previewCallbackFrameCount = 1;
+        final int setAspectRatio = MediaProperties.ASPECT_RATIO_4_3;
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        final Semaphore blockTillPreviewCompletes = new Semaphore(1);
+
+        boolean flagForException = false;
+        final MediaVideoItem mediaVideoItem =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
+                videoItemFileName, renderingMode);
+        mVideoEditor.addMediaItem(mediaVideoItem);
+        mediaVideoItem.setExtractBoundaries(0, 10000);
+        final Bitmap mBitmap1 =  mVideoEditorHelper.getBitmap(overlayFilename1,
+            640, 480);
+        final OverlayFrame overlayOnMvi1 =
+            mVideoEditorHelper.createOverlay(mediaVideoItem, "OverlayOnMvi1",
+                mBitmap1, 0, 5000);
+        mediaVideoItem.addOverlay(overlayOnMvi1);
+
+        final Bitmap mBitmap2 =  mVideoEditorHelper.getBitmap(overlayFilename2,
+            640, 480);
+        final OverlayFrame overlayOnMvi2 =
+            mVideoEditorHelper.createOverlay(mediaVideoItem, "OverlayOnMvi2",
+                mBitmap2, 5000, 9000);
+        mediaVideoItem.addOverlay(overlayOnMvi2);
+
+        List<Overlay> overlayList = mediaVideoItem.getAllOverlays();
+        assertEquals("Overlay Size", 2, overlayList.size());
+        assertEquals("Overlay 1", overlayOnMvi1, overlayList.get(0));
+        assertEquals("Overlay 2", overlayOnMvi2, overlayList.get(1));
+
+        mVideoEditor.setAspectRatio(setAspectRatio);
+
+        validatePreviewProgress(0 /* previewFrom */, previewTo, previewLoop, previewTo);
+    }
+
+    /**
+     * To test Preview : Preview of current Trim applied (with default aspect
+     * ratio)
+     */
+    // TODO : remove TC_PRV_006
+    @LargeTest
+    public void testPreviewWithTrim() throws Exception {
+        final String videoItemFileName = INPUT_FILE_PATH +
+            "H264_BP_640x480_30fps_192kbps_1_5.mp4";
+        final MediaVideoItem mediaVideoItem =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
+                videoItemFileName, MediaItem.RENDERING_MODE_CROPPING);
+        final Semaphore blockTillPreviewCompletes = new Semaphore(1);
+        boolean flagForException = false;
+        mediaVideoItem.setExtractBoundaries(mediaVideoItem.getDuration() / 2,
+            mediaVideoItem.getDuration());
+        mVideoEditor.addMediaItem(mediaVideoItem);
+
+        validatePreviewProgress(1000, -1, false, 0);
+    }
+
+    /**
+     * To test Preview : Preview of current work having Overlay and Effect
+     * applied
+     */
+
+    // TODO : remove TC_PRV_007
+    @LargeTest
+    public void testPreviewWithOverlayEffectKenBurn() throws Exception {
+
+        final String videoItemFileName = INPUT_FILE_PATH +
+            "H264_BP_640x480_30fps_192kbps_1_5.mp4";
+        final String imageItemFileName = INPUT_FILE_PATH + "IMG_640x480.jpg";
+        final String videoItemFileName1 = INPUT_FILE_PATH +
+            "MPEG4_SP_640x480_15fps_512kbps_AACLC_48khz_132kbps_s_0_26.mp4";
+        final String overlayFilename = INPUT_FILE_PATH +
+            "IMG_640x480_Overlay1.png";
+        final Semaphore blockTillPreviewCompletes = new Semaphore(1);
+
+        final MediaVideoItem mediaVideoItem1 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
+                videoItemFileName, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mVideoEditor.addMediaItem(mediaVideoItem1);
+
+        final MediaImageItem mediaImageItem2 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m2",
+                imageItemFileName, 10000, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mVideoEditor.addMediaItem(mediaImageItem2);
+
+        final MediaVideoItem mediaVideoItem3 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m3",
+                videoItemFileName1, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mVideoEditor.addMediaItem(mediaVideoItem3);
+
+        final EffectColor effectColor =
+            mVideoEditorHelper.createEffectItem(mediaVideoItem1, "Effect1",
+                1000, 3000, EffectColor.TYPE_COLOR, EffectColor.GREEN);
+        mediaVideoItem1.addEffect(effectColor);
+
+        final Rect startRect = new Rect((mediaImageItem2.getHeight() / 3),
+            (mediaImageItem2.getWidth() / 3), (mediaImageItem2.getHeight() / 2),
+            (mediaImageItem2.getWidth() / 2));
+        final Rect endRect = new Rect(0, 0, mediaImageItem2.getWidth(),
+            mediaImageItem2.getHeight());
+
+        final EffectKenBurns kbeffectOnMI2 = new EffectKenBurns(mediaImageItem2,
+            "KBOnM2", startRect, endRect, 0, 10000);
+        assertNotNull("EffectKenBurns", kbeffectOnMI2);
+        mediaImageItem2.addEffect(kbeffectOnMI2);
+
+        final Bitmap mBitmap =  mVideoEditorHelper.getBitmap(overlayFilename,
+            640, 480);
+        final OverlayFrame overlayFrame =
+            mVideoEditorHelper.createOverlay(mediaVideoItem3, "OverlayID",
+                mBitmap, (mediaImageItem2.getDuration() / 4),
+                (mediaVideoItem3.getDuration() / 3));
+        mediaVideoItem3.addOverlay(overlayFrame);
+
+        validatePreviewProgress(5000, -1, false, 0);
+    }
+
+    /**
+     *To test Preview : Export during preview
+     */
+    // TODO : remove TC_PRV_008
+    @LargeTest
+    public void testPreviewDuringExport() throws Exception {
+        final String videoItemFileName = INPUT_FILE_PATH +
+            "H264_BP_640x480_30fps_192kbps_1_5.mp4";
+        final Semaphore blockTillPreviewCompletes = new Semaphore(1);
+
+        final MediaVideoItem mediaVideoItem1 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
+                videoItemFileName, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mediaVideoItem1.setExtractBoundaries(0, 20000);
+        mVideoEditor.addMediaItem(mediaVideoItem1);
+
+        mVideoEditor.generatePreview(new MediaProcessingProgressListener() {
+            public void onProgress(Object item, int action, int progress) {
+            }
+        });
+        blockTillPreviewCompletes.acquire();
+
+        final SurfaceHolder surfaceHolder =
+            MediaFrameworkTest.mSurfaceView.getHolder();
+        try {
+            mVideoEditor.startPreview(surfaceHolder, 5000, -1, false, 1,
+                new PreviewProgressListener() {
+                    final String fileName = mVideoEditor.getPath() + "\test.3gp";
+                    final int height = MediaProperties.HEIGHT_360;
+                    final int bitrate = MediaProperties.BITRATE_512K;
+                    public void onProgress(VideoEditor videoEditor, long timeMs,
+                        boolean end) {
+                            if (timeMs >= 10000)
+                            try {
+                                videoEditor.export(fileName, height, bitrate,
+                                    new ExportProgressListener() {
+                                        public void onProgress(VideoEditor ve,
+                                            String outFileName,int progress) {
+                                                blockTillPreviewCompletes.release();
+                                        }
+                                    });
+                            } catch (IOException e) {
+                                assertTrue("UnExpected Error in Export" +
+                                    e.toString(), true);
+                        }
+                    }
+                });
+        } catch (Exception e) {
+            assertTrue("Expected Error in Preview" + e.toString(), true);
+            blockTillPreviewCompletes.release();
+        }
+        blockTillPreviewCompletes.acquire();
+        blockTillPreviewCompletes.release();
+    }
+
+    /**
+     * To test Preview : Preview of current Effects applied (with from time >
+     * total duration)
+     */
+    // TODO : remove TC_PRV_009
+    @LargeTest
+    public void testPreviewWithDurationGreaterThanMediaDuration()
+        throws Exception {
+        final String videoItemFileName = INPUT_FILE_PATH +
+            "H264_BP_640x480_30fps_192kbps_1_5.mp4";
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        final Semaphore blockTillPreviewCompletes = new Semaphore(1);
+
+        boolean flagForException = false;
+
+        final MediaVideoItem mediaVideoItem1 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
+                videoItemFileName, renderingMode);
+        try {
+            mediaVideoItem1.setExtractBoundaries(0, 20000);
+        } catch (Exception e) {
+            assertTrue("Exception during setExtract Boundaries", false);
+        }
+        mVideoEditor.addMediaItem(mediaVideoItem1);
+
+        try {
+            validatePreviewProgress(30000, -1, true, 0);
+        } catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Expected Error in Preview", flagForException);
+    }
+
+    /**
+     * To test Preview : Preview of current Effects applied (with Render Preview
+     * Frame)
+     */
+    // TODO : remove TC_PRV_010
+    @LargeTest
+    public void testPreviewWithRenderPreviewFrame() throws Exception {
+        final String videoItemFileName = INPUT_FILE_PATH +
+            "H264_BP_640x480_30fps_256kbps_1_17.mp4";
+        final Semaphore blockTillPreviewCompletes = new Semaphore(1);
+        boolean flagForException = false;
+
+        final MediaVideoItem mediaVideoItem =
+            mVideoEditorHelper.createMediaItem(mVideoEditor,
+            "m1", videoItemFileName, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mVideoEditor.addMediaItem(mediaVideoItem);
+
+        final EffectColor effectPink =
+            mVideoEditorHelper.createEffectItem(mediaVideoItem,
+                "effectNegativeOnMvi", 1000, 3000, EffectColor.TYPE_COLOR,
+                 EffectColor.PINK);
+        mediaVideoItem.addEffect(effectPink);
+
+        mVideoEditor.generatePreview(new MediaProcessingProgressListener() {
+            public void onProgress(Object item, int action, int progress) {
+            }
+        });
+        final SurfaceHolder surfaceHolder =
+            MediaFrameworkTest.mSurfaceView.getHolder();
+
+        assertEquals("Render preview Frame at 5 Sec", 5000,
+            mVideoEditor.renderPreviewFrame(surfaceHolder, 5000));
+
+        assertEquals("Render preview Frame at 7 Sec", 7000,
+            mVideoEditor.renderPreviewFrame(surfaceHolder, 7000));
+
+        blockTillPreviewCompletes.acquire();
+
+        mVideoEditor.startPreview(surfaceHolder, 5000, -1, false, 1,
+            new PreviewProgressListener() {
+                public void onProgress(VideoEditor videoEditor, long timeMs,
+                    boolean end) {
+                        if (end) {
+                    blockTillPreviewCompletes.release();
+                }
+            }
+        });
+        blockTillPreviewCompletes.acquire();
+        blockTillPreviewCompletes.release();
+    }
+
+    /**
+     * To test Preview : Preview of current work from selected jump location
+     * till end with Audio Track
+     */
+    // TODO : remove TC_PRV_011
+    @LargeTest
+    public void testPreviewWithEndAudioTrack() throws Exception {
+        final String imageItemFilename1 = INPUT_FILE_PATH + "IMG_1600x1200.jpg";
+        final String videoItemFileName = INPUT_FILE_PATH +
+            "H264_BP_640x480_30fps_256kbps_1_17.mp4";
+        final String imageItemFilename2 = INPUT_FILE_PATH + "IMG_640x480.jpg";
+        final String audioFilename = INPUT_FILE_PATH +
+            "AMRNB_8KHz_12.2Kbps_m_1_17.3gp";
+        final Semaphore blockTillPreviewCompletes = new Semaphore(1);
+        boolean flagForException = false;
+
+        final MediaImageItem mediaImageItem1 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
+                imageItemFilename1, 7000, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mVideoEditor.addMediaItem(mediaImageItem1);
+
+        final MediaVideoItem mediaVideoItem =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m2",
+                videoItemFileName, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mediaVideoItem.setExtractBoundaries(1000, 8000);
+        mVideoEditor.addMediaItem(mediaVideoItem);
+
+        final MediaImageItem mediaImageItem2 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m3",
+                imageItemFilename2, 7000, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mVideoEditor.addMediaItem(mediaImageItem2);
+
+        final AudioTrack audioTrack =
+            mVideoEditorHelper.createAudio(mVideoEditor, "a1", audioFilename);
+        mVideoEditor.addAudioTrack(audioTrack);
+
+        List<AudioTrack> audioList = mVideoEditor.getAllAudioTracks();
+        assertEquals("Audio Track List size", 1, audioList.size());
+        assertEquals("Audio Track", audioTrack, audioList.get(0));
+        mVideoEditor.setAspectRatio(MediaProperties.ASPECT_RATIO_4_3);
+
+        validatePreviewProgress(10000, -1, false, 0);
+    }
+
+    /**
+     * To test render Preview Frame
+     */
+    // TODO : remove TC_PRV_012
+    @LargeTest
+    public void testRenderPreviewFrame() throws Exception {
+        final String videoItemFileName1 = INPUT_FILE_PATH
+            + "H264_BP_1080x720_30fps_800kbps_1_17.mp4";
+        final String videoItemFileName2 = INPUT_FILE_PATH
+            + "MPEG4_SP_800x480_515kbps_15fps_AMR_NB_8KHz_12.2kbps_m_0_26.mp4";
+        final String videoItemFileName3 = INPUT_FILE_PATH
+            + "H264_BP_640x480_30fps_256kbps_1_17.mp4";
+        final String imageItemFilename1 = INPUT_FILE_PATH
+            + "IMG_1600x1200.jpg";
+        final String imageItemFilename2 = INPUT_FILE_PATH
+            + "IMG_176x144.jpg";
+        final String audioFilename = INPUT_FILE_PATH
+            + "AMRNB_8KHz_12.2Kbps_m_1_17.3gp";
+
+        final MediaVideoItem mediaVideoItem1 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
+                videoItemFileName1, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mediaVideoItem1.setExtractBoundaries(0, 10000);
+        mVideoEditor.addMediaItem(mediaVideoItem1);
+
+        final MediaVideoItem mediaVideoItem2 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m2",
+                videoItemFileName2, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mediaVideoItem1.setExtractBoundaries(mediaVideoItem2.getDuration() / 4,
+            mediaVideoItem2.getDuration() / 2);
+        mVideoEditor.addMediaItem(mediaVideoItem2);
+
+        final MediaVideoItem mediaVideoItem3 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m3",
+                videoItemFileName3, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mediaVideoItem1.setExtractBoundaries(mediaVideoItem2.getDuration() / 2,
+            mediaVideoItem2.getDuration());
+        mVideoEditor.addMediaItem(mediaVideoItem3);
+
+        final MediaImageItem mediaImageItem4 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m4",
+                imageItemFilename1, 5000, MediaItem.RENDERING_MODE_BLACK_BORDER);
+
+        final MediaImageItem mediaImageItem5 =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m5",
+                imageItemFilename2, 5000, MediaItem.RENDERING_MODE_BLACK_BORDER);
+
+        List<MediaItem> mediaList = mVideoEditor.getAllMediaItems();
+        assertEquals("Media Item List Size", 3, mediaList.size());
+
+        mVideoEditor.insertMediaItem(mediaImageItem4, mediaVideoItem2.getId());
+        mediaList = mVideoEditor.getAllMediaItems();
+        assertEquals("Media Item List Size", 4, mediaList.size());
+        assertEquals("Media item 1", mediaVideoItem1, mediaList.get(0));
+        assertEquals("Media item 2", mediaVideoItem2, mediaList.get(1));
+        assertEquals("Media item 4", mediaImageItem4, mediaList.get(2));
+        assertEquals("Media item 3", mediaVideoItem3, mediaList.get(3));
+
+        mVideoEditor.insertMediaItem(mediaImageItem5, mediaImageItem4.getId());
+        mediaList = mVideoEditor.getAllMediaItems();
+        assertEquals("Media Item List Size", 5, mediaList.size());
+        assertEquals("Media item 1", mediaVideoItem1, mediaList.get(0));
+        assertEquals("Media item 2", mediaVideoItem2, mediaList.get(1));
+        assertEquals("Media item 4", mediaImageItem4, mediaList.get(2));
+        assertEquals("Media item 5", mediaImageItem5, mediaList.get(3));
+        assertEquals("Media item 3", mediaVideoItem3, mediaList.get(4));
+
+        mVideoEditor.moveMediaItem(mediaVideoItem1.getId(),
+            mediaImageItem5.getId());
+        mediaList = mVideoEditor.getAllMediaItems();
+        assertEquals("Media Item List Size", 5, mediaList.size());
+        assertEquals("Media item 2", mediaVideoItem2, mediaList.get(0));
+        assertEquals("Media item 4", mediaImageItem4, mediaList.get(1));
+        assertEquals("Media item 5", mediaImageItem5, mediaList.get(2));
+        assertEquals("Media item 1", mediaVideoItem1, mediaList.get(3));
+        assertEquals("Media item 3", mediaVideoItem3, mediaList.get(4));
+
+        final TransitionCrossfade transition2And4CrossFade =
+            mVideoEditorHelper.createTCrossFade("transition2And4CrossFade",
+                mediaVideoItem2, mediaImageItem4, 2000,
+                Transition.BEHAVIOR_MIDDLE_FAST);
+        mVideoEditor.addTransition(transition2And4CrossFade);
+
+        final TransitionCrossfade transition1And3CrossFade =
+            mVideoEditorHelper.createTCrossFade("transition1And3CrossFade",
+                mediaVideoItem1, mediaVideoItem3, 5000,
+                Transition.BEHAVIOR_MIDDLE_FAST);
+        mVideoEditor.addTransition(transition1And3CrossFade);
+
+        final AudioTrack audioTrack =
+            mVideoEditorHelper.createAudio(mVideoEditor, "a1", audioFilename);
+        audioTrack.setExtractBoundaries(0, 2000);
+        mVideoEditor.addAudioTrack(audioTrack);
+
+        audioTrack.enableLoop();
+        final SurfaceHolder surfaceHolder =
+            MediaFrameworkTest.mSurfaceView.getHolder();
+
+        for (int i = 0; i < mVideoEditor.getDuration(); i += 500) {
+            assertEquals("Render PreviewFram", -1,
+                mVideoEditor.renderPreviewFrame(surfaceHolder, i));
+        }
+    }
+
+    /**
+     * To Test Preview : Without any Media Items in the story Board
+     */
+    // TODO : remove TC_PRV_013
+    @LargeTest
+    public void testStartPreviewWithoutMediaItems() throws Exception {
+        boolean flagForException = false;
+        final SurfaceHolder surfaceHolder =
+            MediaFrameworkTest.mSurfaceView.getHolder();
+        try{
+        mVideoEditor.startPreview(surfaceHolder, 0, -1, false, 1,
+            new PreviewProgressListener() {
+                public void onProgress(VideoEditor videoEditor, long timeMs,
+                    boolean end) {
+                }
+            });
+        }catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Preview without Media Items", flagForException);
+    }
+
+    /**
+     * To Test Preview : Add Media and Remove Media Item (Without any Media
+     * Items in the story Board)
+     */
+    // TODO : remove TC_PRV_014
+    @LargeTest
+    public void testStartPreviewAddRemoveMediaItems() throws Exception {
+        final String videoItemFilename1 = INPUT_FILE_PATH
+            + "H263_profile0_176x144_15fps_256kbps_AACLC_32kHz_128kbps_s_0_26.3gp";
+        final String imageItemFilename1 = INPUT_FILE_PATH + "IMG_1600x1200.jpg";
+        final String alphaFilename = INPUT_FILE_PATH +
+            "TransitionSpiral_QVGA.jpg";
+        boolean flagForException = false;
+
+        final MediaVideoItem mediaVideoItem =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m1",
+                videoItemFilename1, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mediaVideoItem.setExtractBoundaries(0, 15000);
+        mVideoEditor.addMediaItem(mediaVideoItem);
+
+        final MediaImageItem mediaImageItem =
+            mVideoEditorHelper.createMediaItem(mVideoEditor, "m2",
+                imageItemFilename1, 15000, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mVideoEditor.addMediaItem(mediaImageItem);
+
+        final TransitionAlpha transition1And2 =
+            mVideoEditorHelper.createTAlpha("transition", mediaVideoItem,
+                mediaImageItem, 3000, Transition.BEHAVIOR_SPEED_UP,
+                alphaFilename, 10, false);
+        mVideoEditor.addTransition(transition1And2);
+
+        final EffectColor effectColor =
+            mVideoEditorHelper.createEffectItem(mediaImageItem, "effect", 5000,
+                3000, EffectColor.TYPE_COLOR, EffectColor.PINK);
+        mediaImageItem.addEffect(effectColor);
+
+        assertEquals("removing Media item 1", mediaVideoItem,
+            mVideoEditor.removeMediaItem(mediaVideoItem.getId()));
+        assertEquals("removing Media item 2", mediaImageItem,
+            mVideoEditor.removeMediaItem(mediaImageItem.getId()));
+
+        try{
+        mVideoEditor.generatePreview(new MediaProcessingProgressListener() {
+            public void onProgress(Object item, int action, int progress) {
+            }
+        });
+        final SurfaceHolder surfaceHolder =
+            MediaFrameworkTest.mSurfaceView.getHolder();
+        mVideoEditor.startPreview(surfaceHolder, 0, -1, false, 1,
+            new PreviewProgressListener() {
+                public void onProgress(VideoEditor videoEditor, long timeMs,
+                    boolean end) {
+                }
+            });
+        }catch (IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue("Preview with removed Media Items", flagForException);
+    }
+
+    /**
+     * To test Preview : Preview of current Effects applied (with Render Preview
+     * Frame)
+     */
+    // TODO : remove TC_PRV_015
+    @LargeTest
+    public void testPreviewWithRenderPreviewFrameWithoutGenerate() throws Exception {
+        final String videoItemFileName = INPUT_FILE_PATH +
+            "H264_BP_640x480_30fps_256kbps_1_17.mp4";
+        final Semaphore blockTillPreviewCompletes = new Semaphore(1);
+        boolean flagForException = false;
+        long duration = 0;
+
+        final MediaVideoItem mediaVideoItem =
+            mVideoEditorHelper.createMediaItem(mVideoEditor,
+            "m1", videoItemFileName, MediaItem.RENDERING_MODE_BLACK_BORDER);
+        mVideoEditor.addMediaItem(mediaVideoItem);
+
+        final SurfaceHolder surfaceHolder =
+            MediaFrameworkTest.mSurfaceView.getHolder();
+
+        duration = mVideoEditor.getDuration();
+
+        try {
+        assertEquals("Render preview Frame at item duration", duration,
+            mVideoEditor.renderPreviewFrame(surfaceHolder, duration));
+        } catch ( Exception e) {
+            assertTrue (" Render Preview Frame without generate", false);
+        }
+
+        duration = mVideoEditor.getDuration() + 1000;
+        try {
+            mVideoEditor.renderPreviewFrame(surfaceHolder, duration);
+        } catch ( IllegalArgumentException e) {
+            flagForException = true;
+        }
+        assertTrue (" Preview time greater than duration", flagForException);
+        blockTillPreviewCompletes.acquire();
+        blockTillPreviewCompletes.release();
+    }
+
+}
diff --git a/media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/performance/VideoEditorPerformance.java b/media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/performance/VideoEditorPerformance.java
new file mode 100644
index 0000000..d9d07cb
--- /dev/null
+++ b/media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/performance/VideoEditorPerformance.java
@@ -0,0 +1,1096 @@
+/*
+ * Copyright (C) 2011 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.
+ */
+
+
+package com.android.mediaframeworktest.performance;
+
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileWriter;
+import java.io.Writer;
+
+import android.graphics.Bitmap;
+import android.graphics.Rect;
+import android.media.videoeditor.AudioTrack;
+import android.media.videoeditor.EffectColor;
+import android.media.videoeditor.EffectKenBurns;
+import android.media.videoeditor.MediaImageItem;
+import android.media.videoeditor.MediaItem;
+import android.media.videoeditor.MediaProperties;
+import android.media.videoeditor.MediaVideoItem;
+import android.media.videoeditor.OverlayFrame;
+import android.media.videoeditor.Transition;
+import android.media.videoeditor.TransitionCrossfade;
+import android.media.videoeditor.TransitionAlpha;
+import android.media.videoeditor.TransitionFadeBlack;
+import android.media.videoeditor.TransitionSliding;
+import android.media.videoeditor.VideoEditor;
+import android.os.Environment;
+import android.test.ActivityInstrumentationTestCase;
+import android.media.videoeditor.VideoEditor.MediaProcessingProgressListener;
+import android.os.Environment;
+import android.os.SystemClock;
+import android.test.ActivityInstrumentationTestCase;
+import android.media.videoeditor.VideoEditor.ExportProgressListener;
+
+import android.util.Log;
+
+import com.android.mediaframeworktest.MediaFrameworkTest;
+import android.test.suitebuilder.annotation.LargeTest;
+import com.android.mediaframeworktest.VideoEditorHelper;
+
+/**
+ * Junit / Instrumentation - performance measurement for media player and
+ * recorder
+ */
+public class VideoEditorPerformance extends
+    ActivityInstrumentationTestCase<MediaFrameworkTest> {
+
+    private final String TAG = "VideoEditorPerformance";
+
+    private final String PROJECT_LOCATION = VideoEditorHelper.PROJECT_LOCATION_COMMON;
+
+    private final String INPUT_FILE_PATH = VideoEditorHelper.INPUT_FILE_PATH_COMMON;
+
+    private final String VIDEOEDITOR_OUTPUT = PROJECT_LOCATION +
+        "VideoEditorPerformance.txt";
+
+    public VideoEditorPerformance() {
+        super("com.android.mediaframeworktest", MediaFrameworkTest.class);
+    }
+
+    private final String PROJECT_CLASS_NAME =
+        "android.media.videoeditor.VideoEditorImpl";
+    private VideoEditor mVideoEditor;
+    private VideoEditorHelper mVideoEditorHelper;
+
+    @Override
+    protected void setUp() throws Exception {
+        // setup for each test case.
+        super.setUp();
+        mVideoEditorHelper = new VideoEditorHelper();
+        // Create a random String which will be used as project path, where all
+        // project related files will be stored.
+        final String projectPath =
+            mVideoEditorHelper.createRandomFile(PROJECT_LOCATION);
+        mVideoEditor = mVideoEditorHelper.createVideoEditor(projectPath);
+    }
+
+    @Override
+    protected void tearDown() throws Exception {
+        mVideoEditorHelper.destroyVideoEditor(mVideoEditor);
+        // Clean the directory created as project path
+        mVideoEditorHelper.deleteProject(new File(mVideoEditor.getPath()));
+        System.gc();
+        super.tearDown();
+    }
+
+    private void writeTimingInfo(String testCaseName, String[] information)
+        throws Exception {
+        File outFile = new File(VIDEOEDITOR_OUTPUT);
+        Writer output = new BufferedWriter(new FileWriter(outFile, true));
+        output.write(testCaseName + "\n\t");
+        for (int i = 0; i < information.length; i++) {
+            output.write(information[i]);
+        }
+        output.write("\n\n");
+        output.close();
+    }
+
+    private final int NUM_OF_ITERATIONS=20;
+
+    private float calculateTimeTaken(long beginTime, int numIterations)
+        throws Exception {
+        final long duration2 = SystemClock.uptimeMillis();
+        final long durationToCreateMediaItem = (duration2 - beginTime);
+        final float timeTaken1 = (float)durationToCreateMediaItem *
+            1.0f/(float)numIterations;
+        return (timeTaken1);
+    }
+
+    private void createVideoItems(MediaVideoItem[] mediaVideoItem,
+        String videoItemFileName, int renderingMode, int startTime, int endTime) throws Exception {
+        for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
+            try {
+                mediaVideoItem[i] = new MediaVideoItem(mVideoEditor, "m" + i,
+                    videoItemFileName, renderingMode);
+                mediaVideoItem[i].setExtractBoundaries(startTime, endTime);
+            } catch (Exception e1) {
+                assertTrue(
+                    "Can not create an object of Video Item with file name = "
+                    + videoItemFileName + "------ID:m" + i + "       Issue = "
+                    + e1.toString(), false);
+            }
+        }
+    }
+
+    private void addVideoItems(MediaVideoItem[] mediaVideoItem) throws Exception {
+        for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
+            try {
+                mVideoEditor.addMediaItem(mediaVideoItem[i]);
+            } catch (Exception e1) {
+                assertTrue(
+                    "Can not add an object of Video Item with ID:m" + i +
+                    "    Issue = " + e1.toString(), false);
+            }
+        }
+    }
+
+    private void removeVideoItems(MediaVideoItem[] mediaVideoItem) throws Exception {
+            for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
+            try {
+            mVideoEditor.removeMediaItem(mediaVideoItem[i].getId());
+            } catch (Exception e1) {
+                assertTrue(
+                    "Can not Remove an object of Video Item with ID:m" + i +
+                    "    Issue = " + e1.toString(), false);
+            }
+        }
+    }
+
+    private void createImageItems(MediaImageItem[] mIi,
+        String imageItemFileName, int renderingMode, int duration) throws Exception {
+        for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
+            try {
+                mIi[i] = new MediaImageItem(mVideoEditor, "m" + i,
+                    imageItemFileName, duration, renderingMode);
+            } catch (Exception e1) {
+                assertTrue( " Cannot create Image Item", false);
+            }
+        }
+    }
+
+    private void addImageItems(MediaImageItem[] mIi) throws Exception {
+        for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
+            try {
+                mVideoEditor.addMediaItem(mIi[i]);
+            } catch (Exception e1) {
+                assertTrue("Cannot add Image item", false);
+            }
+        }
+    }
+
+    private void removeImageItems(MediaImageItem[] mIi) throws Exception {
+            for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
+            try {
+            mVideoEditor.removeMediaItem(mIi[i].getId());
+            } catch (Exception e1) {
+                assertTrue("Cannot remove image item", false);
+            }
+        }
+    }
+    /**
+     * To test the performance of adding and removing the video media item
+     *
+     * @throws Exception
+     */
+    // TODO : remove PRF_001
+    @LargeTest
+    public void testPerformanceAddRemoveVideoItem() throws Exception {
+        final String videoItemFileName = INPUT_FILE_PATH +
+            "H264_BP_1080x720_30fps_800kbps_1_17.mp4";
+        final int videoItemStartTime = 0;
+        final int videoItemEndTime = 5000;
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        final String[] loggingInfo = new String[3];
+        final MediaVideoItem[] mediaVideoItem =
+            new MediaVideoItem[NUM_OF_ITERATIONS];
+        float timeTaken = 0.0f;
+        long startTime = 0;
+
+        /** Time Take for creation of Media Video Item */
+        startTime = SystemClock.uptimeMillis();
+        createVideoItems(mediaVideoItem, videoItemFileName, renderingMode,
+            videoItemStartTime, videoItemEndTime);
+
+        timeTaken = calculateTimeTaken (startTime, NUM_OF_ITERATIONS);
+        loggingInfo[0] = "Time taken to Create Media Video Item\t" +
+            timeTaken;
+
+        /** Time Take for Addition of Media Video Item */
+        startTime = SystemClock.uptimeMillis();
+        addVideoItems(mediaVideoItem);
+        timeTaken = calculateTimeTaken (startTime, NUM_OF_ITERATIONS);
+        loggingInfo[1] = "\n\tTime taken to Add  Media Video Item\t"
+            + timeTaken;
+
+        /** Time Take for Removal of Media Video Item */
+        startTime = SystemClock.uptimeMillis();
+        removeVideoItems(mediaVideoItem);
+        timeTaken = calculateTimeTaken (startTime, NUM_OF_ITERATIONS);
+        loggingInfo[2] = "\n\tTime taken to remove  Media Video Item\t"
+            + timeTaken;
+
+        writeTimingInfo("testPerformanceAddRemoveVideoItem (in mSec)", loggingInfo);
+    }
+
+    /**
+     * To test the performance of adding and removing the image media item
+     *
+     * @throws Exception
+     */
+    // TODO : remove PRF_002
+    @LargeTest
+    public void testPerformanceAddRemoveImageItem() throws Exception {
+        final String imageItemFileName = INPUT_FILE_PATH + "IMG_1600x1200.jpg";
+        final int imageItemDuration = 0;
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        final String[] loggingInfo = new String[3];
+        final MediaImageItem[] mediaImageItem =
+            new MediaImageItem[NUM_OF_ITERATIONS];
+        float timeTaken = 0.0f;
+
+        long beginTime = SystemClock.uptimeMillis();
+        createImageItems(mediaImageItem, imageItemFileName, renderingMode,
+            imageItemDuration);
+        timeTaken = calculateTimeTaken(beginTime, NUM_OF_ITERATIONS);
+        loggingInfo[0] = "Time taken to Create  Media Image Item\t" +
+            timeTaken;
+
+        beginTime = SystemClock.uptimeMillis();
+        addImageItems(mediaImageItem);
+        timeTaken = calculateTimeTaken(beginTime, NUM_OF_ITERATIONS);
+        loggingInfo[1] = "\n\tTime taken to add  Media Image Item\t" +
+            timeTaken;
+
+        beginTime = SystemClock.uptimeMillis();
+        removeImageItems(mediaImageItem);
+        timeTaken = calculateTimeTaken(beginTime, NUM_OF_ITERATIONS);
+        loggingInfo[2] = "\n\tTime taken to remove  Media Image Item\t"
+            + timeTaken;
+
+        writeTimingInfo("testPerformanceAddRemoveImageItem (in mSec)",
+            loggingInfo);
+    }
+
+    /**
+     * To test the performance of adding and removing the transition
+     *
+     * @throws Exception
+     */
+    // TODO : remove PRF_003
+    @LargeTest
+    public void testPerformanceAddRemoveTransition() throws Exception {
+        final String videoItemFileName1 = INPUT_FILE_PATH +
+        "H264_BP_1080x720_30fps_800kbps_1_17.mp4";
+        final int videoItemStartTime1 = 0;
+        final int videoItemEndTime1 = 20000;
+        final String videoItemFileName2 = INPUT_FILE_PATH
+            + "MPEG4_SP_640x480_15fps_512kbps_AACLC_48khz_132kbps_s_0_26.mp4";
+        final int videoItemStartTime2 = 0;
+        final int videoItemEndTime2 = 20000;
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        final int transitionDuration = 5000;
+        final int transitionBehavior = Transition.BEHAVIOR_MIDDLE_FAST;
+        final String[] loggingInfo = new String[3];
+        float timeTaken = 0.0f;
+
+        final MediaVideoItem[] mediaVideoItem =
+            new MediaVideoItem[(NUM_OF_ITERATIONS *10) + 1];
+
+        for (int i = 0; i < (NUM_OF_ITERATIONS *10); i+=2) {
+            try {
+                mediaVideoItem[i] = new MediaVideoItem(mVideoEditor, "m" + i,
+                    videoItemFileName1, renderingMode);
+                mediaVideoItem[i+1] = new MediaVideoItem(mVideoEditor,
+                    "m" + (i+1), videoItemFileName2, renderingMode);
+                mediaVideoItem[i].setExtractBoundaries(videoItemStartTime1,
+                    videoItemEndTime1);
+                mediaVideoItem[i+1].setExtractBoundaries(videoItemStartTime2,
+                    videoItemEndTime2);
+            } catch (Exception e1) {
+                assertTrue("Can not create Video Object Item with file name = "
+                    + e1.toString(), false);
+            }
+            mVideoEditor.addMediaItem(mediaVideoItem[i]);
+            mVideoEditor.addMediaItem(mediaVideoItem[i+1]);
+        }
+        mediaVideoItem[(NUM_OF_ITERATIONS *10)] = new MediaVideoItem(mVideoEditor,
+            "m" + (NUM_OF_ITERATIONS *10), videoItemFileName1, renderingMode);
+        mediaVideoItem[(NUM_OF_ITERATIONS *10)].setExtractBoundaries(
+            videoItemStartTime1, videoItemEndTime1);
+        mVideoEditor.addMediaItem(mediaVideoItem[(NUM_OF_ITERATIONS *10)]);
+        final TransitionCrossfade tranCrossfade[] =
+            new TransitionCrossfade[(NUM_OF_ITERATIONS *10)];
+
+        long beginTime = SystemClock.uptimeMillis();
+        for (int i = 0; i < (NUM_OF_ITERATIONS *10); i++) {
+            tranCrossfade[i] = new TransitionCrossfade("transition" + i,
+                mediaVideoItem[i], mediaVideoItem[i+1], transitionDuration,
+                transitionBehavior);
+        }
+        timeTaken = calculateTimeTaken(beginTime, (NUM_OF_ITERATIONS * 10));
+        loggingInfo[0] = "Time taken to Create CrossFade Transition\t" +
+            timeTaken;
+
+        beginTime = SystemClock.uptimeMillis();
+        for (int i = 0; i < (NUM_OF_ITERATIONS *10); i++) {
+            mVideoEditor.addTransition(tranCrossfade[i]);
+        }
+        timeTaken = calculateTimeTaken(beginTime, (NUM_OF_ITERATIONS * 10));
+        loggingInfo[1] = "\n\tTime taken to add CrossFade Transition\t" +
+            timeTaken;
+
+        beginTime = SystemClock.uptimeMillis();
+        for (int i = 0; i < (NUM_OF_ITERATIONS *10); i++) {
+            assertEquals("Removing Transitions", tranCrossfade[i], mVideoEditor
+                .removeTransition(tranCrossfade[i].getId()));
+        }
+        timeTaken = calculateTimeTaken(beginTime, (NUM_OF_ITERATIONS * 10));
+        loggingInfo[2] = "\n\tTime taken to remove CrossFade Transition\t" +
+            timeTaken;
+
+        writeTimingInfo("testPerformanceAddRemoveTransition (in mSec)", loggingInfo);
+    }
+
+    /**
+     * To test performance of Export
+     *
+     * @throws Exception
+     */
+    // TODO : remove PRF_004
+    @LargeTest
+    public void testPerformanceExport() throws Exception {
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        final int outHeight = MediaProperties.HEIGHT_480;
+        final int outBitrate = MediaProperties.BITRATE_256K;
+        final int outVcodec = MediaProperties.VCODEC_H264BP;
+        final String[] loggingInfo = new String[1];
+        final String outFilename = mVideoEditorHelper
+            .createRandomFile(mVideoEditor.getPath() + "/") + ".3gp";
+        final String videoItemFileName1 = INPUT_FILE_PATH +
+            "H264_BP_1080x720_30fps_12Mbps_AACLC_44.1khz_64kbps_s_1_17.mp4";
+        final String imageItemFileName1 = INPUT_FILE_PATH + "IMG_1600x1200.jpg";
+        final String videoItemFileName2 = INPUT_FILE_PATH +
+            "H264_BP_640x480_15fps_1200Kbps_AACLC_48KHz_32kbps_m_1_17.3gp";
+        final String imageItemFileName2 = INPUT_FILE_PATH + "IMG_176x144.jpg";
+        final String videoItemFileName3 = INPUT_FILE_PATH +
+            "MPEG4_SP_720x480_30fps_280kbps_AACLC_48kHz_161kbps_s_0_26.mp4";
+        final String overlayFile = INPUT_FILE_PATH + "IMG_640x480_Overlay1.png";
+        final String audioTrackFilename = INPUT_FILE_PATH +
+            "AMRNB_8KHz_12.2Kbps_m_1_17.3gp";
+        final String maskFilename = INPUT_FILE_PATH +
+            "TransitionSpiral_QVGA.jpg";
+
+        final MediaVideoItem mediaItem1 = new MediaVideoItem(mVideoEditor,
+            "m1", videoItemFileName1, renderingMode);
+        mediaItem1.setExtractBoundaries(0, 20000);
+        mVideoEditor.addMediaItem(mediaItem1);
+
+        final MediaImageItem mediaItem2 = new MediaImageItem(mVideoEditor,
+            "m2", imageItemFileName1, 10000, renderingMode);
+        mVideoEditor.addMediaItem(mediaItem2);
+
+        final MediaVideoItem mediaItem3 = new MediaVideoItem(mVideoEditor,
+            "m3", videoItemFileName2, renderingMode);
+        mediaItem3.setExtractBoundaries(0, 20000);
+        mVideoEditor.addMediaItem(mediaItem3);
+
+        final MediaImageItem mediaItem4 = new MediaImageItem(mVideoEditor,
+            "m4", imageItemFileName2, 10000, renderingMode);
+        mVideoEditor.addMediaItem(mediaItem4);
+
+        final MediaVideoItem mediaItem5 = new MediaVideoItem(mVideoEditor,
+            "m5", videoItemFileName3, renderingMode);
+        mediaItem5.setExtractBoundaries(0, 20000);
+        mVideoEditor.addMediaItem(mediaItem5);
+        /**
+         * 7.Add TransitionAlpha, Apply this  Transition as Begin for Media Item 1
+         *  with duration = 2 sec behavior = BEHAVIOR_LINEAR, mask file name =
+         * TransitionSpiral_QVGA.jpg , blending percent = 50%, invert = true;
+         * */
+        final TransitionAlpha transition1 =
+            mVideoEditorHelper.createTAlpha("transition1", null, mediaItem1,
+                2000, Transition.BEHAVIOR_LINEAR, maskFilename, 50, true);
+        mVideoEditor.addTransition(transition1);
+
+        /**
+         * 8.Add Transition Sliding between MediaItem 2 and 3 ,
+         *  Sliding Direction  = DIRECTION_RIGHT_OUT_LEFT_IN,
+         *  behavior  = BEHAVIOR_MIDDLE_FAST and duration = 4sec
+         * */
+        final TransitionSliding transition2And3 =
+            mVideoEditorHelper.createTSliding("transition2", mediaItem2,
+                mediaItem3, 4000, Transition.BEHAVIOR_MIDDLE_FAST,
+                TransitionSliding.DIRECTION_RIGHT_OUT_LEFT_IN);
+        mVideoEditor.addTransition(transition2And3);
+
+        /**
+         * 9.Add Transition Crossfade between  Media Item 3 and 4,
+         *  behavior = BEHAVIOR_MIDDLE_SLOW, duration = 3.5 sec
+         * */
+        final TransitionCrossfade transition3And4 =
+            mVideoEditorHelper.createTCrossFade("transition3", mediaItem3,
+                mediaItem4, 3500, Transition.BEHAVIOR_MIDDLE_SLOW);
+        mVideoEditor.addTransition(transition3And4);
+
+        /**
+         * 10.Add Transition Fadeblack between  Media Item 4 and 5,
+         *  behavior = BEHAVIOR_SPEED_DOWN, duration = 3.5 sec
+         * */
+        final TransitionFadeBlack transition4And5 =
+            mVideoEditorHelper.createTFadeBlack("transition4", mediaItem4,
+                mediaItem5, 3500, Transition.BEHAVIOR_SPEED_DOWN);
+        mVideoEditor.addTransition(transition4And5);
+
+        /**
+         * 11.Add Effect 1 type="TYPE_SEPIA" to the MediaItem 1,
+         *  start time=1sec and duration =4secs
+         * */
+        final EffectColor effectColor1 = mVideoEditorHelper.createEffectItem(
+            mediaItem1, "effect1", 1000, 4000, EffectColor.TYPE_SEPIA, 0);
+        mediaItem1.addEffect(effectColor1);
+
+        /**
+         * 12.Add Overlay 1  to the MediaItem 3: Frame Overlay with start time = 1 sec
+         * duration = 4 sec with item  = IMG_640x480_Overlay1.png
+         * */
+        final Bitmap mBitmap =  mVideoEditorHelper.getBitmap(overlayFile, 640,
+            480);
+        final OverlayFrame overlayFrame =
+            mVideoEditorHelper.createOverlay(mediaItem3, "overlay",
+                mBitmap, 1000, 4000);
+        mediaItem3.addOverlay(overlayFrame);
+        /**
+         * 13.Add Effect 2 type="TYPE_NEGATIVE" to the MediaItem 2,
+         *  start time=8sec and duration =2secs
+         * */
+        final EffectColor effectColor2 = mVideoEditorHelper.createEffectItem(
+            mediaItem2, "effect2", 8000, 2000, EffectColor.TYPE_NEGATIVE, 0);
+        mediaItem2.addEffect(effectColor2);
+        /**
+         * 14.Add Effect 3 type="TYPE_COLOR" to the MediaItem 3, color param = "PINK",
+         *  start time=5 sec and duration =3secs
+         * */
+        final EffectColor effectColor3 = mVideoEditorHelper.createEffectItem(
+            mediaItem3, "effect3", 5000, 3000, EffectColor.TYPE_COLOR,
+            EffectColor.PINK);
+        mediaItem3.addEffect(effectColor3);
+        /**
+         * 15.Add Effect 4 type="TYPE_FIFTIES" to the MediaItem 4,
+         *  start time=2 sec and duration =1secs
+        * */
+        final EffectColor effectColor4 = mVideoEditorHelper.createEffectItem(
+            mediaItem4, "effect4", 2000, 1000, EffectColor.TYPE_FIFTIES, 0);
+        mediaItem4.addEffect(effectColor4);
+        /**
+         * 16.Add KenBurnsEffect for MediaItem 4 with
+         *  duration = 3 sec and startTime = 4 sec
+         *  StartRect
+         *  left = org_height/3  ;  top = org_width/3
+         *  bottom = org_width/2  ;  right = org_height/2
+         *  EndRect
+         *  left = 0  ;  top = 0
+         *  bottom =  org_height;  right =  org_width
+         * */
+
+        final Rect startRect = new Rect((mediaItem4.getHeight() / 3),
+            (mediaItem4.getWidth() / 3), (mediaItem4.getHeight() / 2),
+            (mediaItem4.getWidth() / 2));
+        final Rect endRect = new Rect(0, 0, mediaItem4.getWidth(),
+            mediaItem4.getHeight());
+        final EffectKenBurns kbEffectOnMediaItem = new EffectKenBurns(
+            mediaItem4, "KBOnM2", startRect, endRect,4000 , 3000);
+        mediaItem4.addEffect(kbEffectOnMediaItem);
+
+        /** 17.Add Audio Track,Set extract boundaries o to 10 sec.
+         * */
+        final AudioTrack audioTrack = mVideoEditorHelper.createAudio(
+            mVideoEditor, "audioTrack", audioTrackFilename);
+        mVideoEditor.addAudioTrack(audioTrack);
+        /** 18.Enable Looping for Audio Track.
+         * */
+        audioTrack.enableLoop();
+        float timeTaken = 0.0f;
+        final long beginTime = SystemClock.uptimeMillis();
+            try {
+                mVideoEditor.export(outFilename, outHeight, outBitrate, /*0,
+                    outVcodec,*/ new ExportProgressListener() {
+                        public void onProgress(VideoEditor ve,
+                            String outFileName, int progress) {
+                        }
+                    });
+            } catch (Exception e) {
+                assertTrue("Error in Export" + e.toString(), false);
+            }
+        mVideoEditorHelper.checkDeleteExistingFile(outFilename);
+
+        timeTaken = calculateTimeTaken(beginTime, 1);
+        loggingInfo[0] = "Time taken to do ONE export of storyboard duration\t"
+            + mVideoEditor.getDuration() + "   is   :\t" + timeTaken;
+
+        writeTimingInfo("testPerformanceExport (in mSec)", loggingInfo);
+        mVideoEditorHelper.deleteProject(new File(mVideoEditor.getPath()));
+    }
+
+
+    /**
+     * To test the performance of thumbnail extraction
+     *
+     * @throws Exception
+     */
+    // TODO : remove PRF_005
+    @LargeTest
+    public void testPerformanceThumbnailVideoItem() throws Exception {
+        final String videoItemFileName = INPUT_FILE_PATH
+            + "MPEG4_SP_640x480_15fps_512kbps_AACLC_48khz_132kbps_s_0_26.mp4";
+        final int videoItemStartTime = 0;
+        final int videoItemEndTime = 20000;
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        final String[] loggingInfo = new String[1];
+
+        final MediaVideoItem mediaVideoItem = new MediaVideoItem(mVideoEditor,
+            "m1", videoItemFileName, renderingMode);
+        mediaVideoItem.setExtractBoundaries(videoItemStartTime,
+            videoItemEndTime);
+
+        float timeTaken = 0.0f;
+        long beginTime = SystemClock.uptimeMillis();
+        for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
+            mediaVideoItem.getThumbnail(mediaVideoItem.getWidth() / 2,
+                mediaVideoItem.getHeight() / 2, i);
+        }
+        timeTaken = calculateTimeTaken(beginTime, NUM_OF_ITERATIONS);
+        loggingInfo[0] = "Duration taken to get Video Thumbnails\t" +
+            timeTaken;
+
+        writeTimingInfo("testPerformanceThumbnailVideoItem (in mSec)", loggingInfo);
+    }
+
+    /**
+     * To test the performance of adding and removing the overlay to media item
+     *
+     * @throws Exception
+     */
+    // TODO : remove PRF_006
+    @LargeTest
+    public void testPerformanceOverlayVideoItem() throws Exception {
+        final String videoItemFileName1 = INPUT_FILE_PATH +
+            "MPEG4_SP_640x480_15fps_512kbps_AACLC_48khz_132kbps_s_0_26.mp4";
+        final int videoItemStartTime1 = 0;
+        final int videoItemEndTime1 = 10000;
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        final String overlayFilename = INPUT_FILE_PATH
+            + "IMG_640x480_Overlay1.png";
+        final int overlayStartTime = 1000;
+        final int overlayDuration = 5000;
+
+        final String[] loggingInfo = new String[2];
+        MediaVideoItem mediaVideoItem = null;
+
+        try {
+            mediaVideoItem = new MediaVideoItem(mVideoEditor, "m0",
+                videoItemFileName1, renderingMode);
+            mediaVideoItem.setExtractBoundaries(videoItemStartTime1,
+                videoItemEndTime1);
+        } catch (Exception e1) {
+            assertTrue("Can not create Video Item with file name = "
+                + e1.toString(), false);
+        }
+        final OverlayFrame overlayFrame[] = new OverlayFrame[NUM_OF_ITERATIONS];
+        final Bitmap mBitmap =  mVideoEditorHelper.getBitmap(overlayFilename,
+            640, 480);
+        float timeTaken = 0.0f;
+        long beginTime = SystemClock.uptimeMillis();
+        for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
+            overlayFrame[i] = new OverlayFrame(mediaVideoItem, "overlay" + i,
+            mBitmap, overlayStartTime, overlayDuration);
+            mediaVideoItem.addOverlay(overlayFrame[i]);
+        }
+        timeTaken = calculateTimeTaken(beginTime, NUM_OF_ITERATIONS);
+        loggingInfo[0] = "Time taken to add & create Overlay\t" + timeTaken;
+
+        beginTime = SystemClock.uptimeMillis();
+        for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
+            assertEquals("Removing Overlays", overlayFrame[i],
+                mediaVideoItem.removeOverlay((overlayFrame[i].getId())));
+        }
+        timeTaken = calculateTimeTaken(beginTime, NUM_OF_ITERATIONS);
+        loggingInfo[1] = "\n\tTime taken to remove  Overlay\t" +
+            timeTaken;
+
+        writeTimingInfo("testPerformanceOverlayVideoItem (in mSec)", loggingInfo);
+    }
+
+    /**
+     * To test the performance of get properties of a Video media item
+     *
+     * @throws Exception
+     */
+    // TODO : remove PRF_007
+    @LargeTest
+    public void testPerformanceVideoItemProperties() throws Exception {
+        final String videoItemFileName1 = INPUT_FILE_PATH +
+            "H264_BP_1080x720_30fps_800kbps_1_17.mp4";
+        final int videoItemStartTime1 = 0;
+        final int videoItemEndTime1 = 10100;
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        final int aspectRatio = MediaProperties.ASPECT_RATIO_3_2;
+        final int fileType = MediaProperties.FILE_MP4;
+        final int videoCodecType = MediaProperties.VCODEC_H264BP;
+        final int duration = 77366;
+        final int videoBitrate = 3169971;
+        final int fps = 30;
+        final int videoProfile = 0;
+        final int width = 1080;
+        final int height = MediaProperties.HEIGHT_720;
+        float timeTaken = 0.0f;
+        final String[] loggingInfo = new String[1];
+        final MediaVideoItem mediaVideoItem = new MediaVideoItem(mVideoEditor,
+            "m0", videoItemFileName1, renderingMode);
+        mediaVideoItem.setExtractBoundaries(videoItemStartTime1,
+            videoItemEndTime1);
+        long beginTime = SystemClock.uptimeMillis();
+        for (int i = 0; i < (NUM_OF_ITERATIONS*10); i++) {
+            try {
+                assertEquals("Aspect Ratio Mismatch",
+                    aspectRatio, mediaVideoItem.getAspectRatio());
+                assertEquals("File Type Mismatch",
+                    fileType, mediaVideoItem.getFileType());
+                assertEquals("VideoCodec Mismatch",
+                    videoCodecType, mediaVideoItem.getVideoType());
+                assertEquals("duration Mismatch",
+                    duration, mediaVideoItem.getDuration());
+/*
+                if (videoBitrate != 0) {
+                    assertTrue("VideoBitrate Mismatch <expected> " + videoBitrate + "\t<actual> "
+                        + mediaVideoItem.getVideoBitrate(), mVideoEditorHelper.checkRange(
+                        videoBitrate, mediaVideoItem.getVideoBitrate(), 10));
+                }
+
+                assertTrue("fps Mismatch", mVideoEditorHelper.checkRange(fps,
+                    mediaVideoItem.getFps(), 10));
+*/
+                assertEquals("Video Profile ",
+                    videoProfile, mediaVideoItem.getVideoProfile());
+                assertEquals("Video height ",
+                    height, mediaVideoItem.getHeight());
+                assertEquals("Video width ",
+                    width, mediaVideoItem.getWidth());
+            } catch (Exception e1) {
+                assertTrue("Can not create Video Item with file name = "
+                    + e1.toString(), false);
+            }
+        }
+        timeTaken = calculateTimeTaken(beginTime, (NUM_OF_ITERATIONS*10));
+        loggingInfo[0] = "Time taken to get Media Properties\t"
+            + timeTaken;
+        writeTimingInfo("testPerformanceVideoItemProperties:", loggingInfo);
+    }
+
+    /**
+     * To test the performance of generatePreview : with Transitions
+     *
+     * @throws Exception
+     */
+    // TODO : remove PRF_008
+    @LargeTest
+    public void testPerformanceGeneratePreviewWithTransitions()
+        throws Exception {
+        final String videoItemFileName = INPUT_FILE_PATH +
+            "H264_BP_1080x720_30fps_800kbps_1_17.mp4";
+        final String imageItemFileName = INPUT_FILE_PATH +
+            "IMG_1600x1200.jpg";
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        final int transitionBehavior = Transition.BEHAVIOR_MIDDLE_FAST;
+        long averageTime = 0;
+        final String[] loggingInfo = new String[1];
+
+        final MediaVideoItem mediaVideoItem = new MediaVideoItem(mVideoEditor,
+            "mediaItem1", videoItemFileName, renderingMode);
+        mediaVideoItem.setExtractBoundaries(0, 10000);
+        mVideoEditor.addMediaItem(mediaVideoItem);
+
+        final MediaImageItem mediaImageItem = new MediaImageItem(mVideoEditor,
+            "mediaItem2", imageItemFileName, 10000, renderingMode);
+        mVideoEditor.addMediaItem(mediaImageItem);
+
+        final TransitionCrossfade transitionCrossFade = new TransitionCrossfade(
+            "transitionCrossFade", mediaVideoItem, mediaImageItem,
+            5000, transitionBehavior);
+        mVideoEditor.addTransition(transitionCrossFade);
+
+        for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
+            final long duration1 = SystemClock.uptimeMillis();
+            mVideoEditor.generatePreview(new MediaProcessingProgressListener() {
+                public void onProgress(Object item, int action, int progress) {
+                }
+            });
+            final long duration2 = SystemClock.uptimeMillis();
+            mVideoEditor.removeTransition(transitionCrossFade.getId());
+            mVideoEditor.addTransition(transitionCrossFade);
+            averageTime += (duration2 - duration1);
+        }
+        final long durationToAddObjects = averageTime;
+        final float timeTaken = (float)durationToAddObjects *
+            1.0f/(float)NUM_OF_ITERATIONS;
+        loggingInfo[0] = "Time taken to Generate Preview with transition\t"
+            + timeTaken;
+        writeTimingInfo("testPerformanceGeneratePreviewWithTransitions:",
+            loggingInfo);
+    }
+
+    /**
+     * To test the performance of generatePreview : with KenBurn
+     *
+     * @throws Exception
+     */
+    // TODO : remove PRF_009
+    @LargeTest
+    public void testPerformanceWithKenBurn() throws Exception {
+        final String videoItemFileName = INPUT_FILE_PATH +
+            "H264_BP_1080x720_30fps_800kbps_1_17.mp4";
+        final String imageItemFileName = INPUT_FILE_PATH +
+            "IMG_1600x1200.jpg";
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        long averageTime = 0;
+        final String[] loggingInfo = new String[1];
+        final MediaVideoItem mediaVideoItem = new MediaVideoItem(mVideoEditor,
+            "mediaItem1", videoItemFileName, renderingMode);
+        mediaVideoItem.setExtractBoundaries(0, 10000);
+        mVideoEditor.addMediaItem(mediaVideoItem);
+
+        final MediaImageItem mediaImageItem = new MediaImageItem(mVideoEditor,
+            "mediaItem2", imageItemFileName, 10000, renderingMode);
+        mVideoEditor.addMediaItem(mediaImageItem);
+
+        final Rect startRect = new Rect((mediaImageItem.getHeight() / 3),
+            (mediaImageItem.getWidth() / 3), (mediaImageItem.getHeight() / 2),
+            (mediaImageItem.getWidth() / 2));
+        final Rect endRect = new Rect(0, 0, mediaImageItem.getWidth(),
+            mediaImageItem.getHeight());
+        final EffectKenBurns kbEffectOnMediaItem =
+            new EffectKenBurns(mediaImageItem, "KBOnM2", startRect, endRect,
+                500, 3000);
+        mediaImageItem.addEffect(kbEffectOnMediaItem);
+
+        for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
+            final long duration1 = SystemClock.uptimeMillis();
+            mVideoEditor.generatePreview(new MediaProcessingProgressListener() {
+                public void onProgress(Object item, int action, int progress) {
+                }
+            });
+            final long duration2 = SystemClock.uptimeMillis();
+            mediaImageItem.removeEffect(kbEffectOnMediaItem.getId());
+            mediaImageItem.addEffect(kbEffectOnMediaItem);
+            averageTime += duration2 - duration1;
+        }
+
+        final long durationToAddObjects = (averageTime);
+        final float timeTaken = (float)durationToAddObjects *
+            1.0f/(float)NUM_OF_ITERATIONS;
+        loggingInfo[0] = "Time taken to Generate KenBurn Effect \t"
+            + timeTaken;
+        writeTimingInfo("testPerformanceWithKenBurn", loggingInfo);
+    }
+
+    /**
+     * To test the performance of generatePreview : with Transitions and
+     * Effect,Overlapping scenario
+     *
+     * @throws Exception
+     */
+    // TODO : remove PRF_010
+    @LargeTest
+    public void testPerformanceEffectOverlappingTransition() throws Exception {
+        final String videoItemFileName1 = INPUT_FILE_PATH +
+            "H264_BP_1080x720_30fps_800kbps_1_17.mp4";
+        final String videoItemFileName2 = INPUT_FILE_PATH
+            + "MPEG4_SP_640x480_15fps_512kbps_AACLC_48khz_132kbps_s_0_26.mp4";
+        final int videoStartTime1 = 0;
+        final int videoEndTime1 = 10000;
+        final int videoStartTime2 = 0;
+        final int videoEndTime2 = 10000;
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        final int transitionDuration = 5000;
+        final int transitionBehavior = Transition.BEHAVIOR_MIDDLE_FAST;
+        final int effectItemStartTime = 5000;
+        final int effectItemDurationTime = 5000;
+        final int effectType = EffectColor.TYPE_COLOR;
+        final int effectColorType = EffectColor.GREEN;
+        long averageDuration = 0;
+
+        final String[] loggingInfo = new String[1];
+        final MediaVideoItem mediaVideoItem1 = new MediaVideoItem(mVideoEditor,
+            "mediaItem1", videoItemFileName1, renderingMode);
+        mediaVideoItem1.setExtractBoundaries(videoStartTime1, videoEndTime1);
+        mVideoEditor.addMediaItem(mediaVideoItem1);
+
+        final MediaVideoItem mediaVideoItem2 = new MediaVideoItem(mVideoEditor,
+            "mediaItem2", videoItemFileName2, renderingMode);
+        mediaVideoItem2.setExtractBoundaries(videoStartTime2, videoEndTime2);
+        mVideoEditor.addMediaItem(mediaVideoItem2);
+
+        final TransitionCrossfade transitionCrossFade = new TransitionCrossfade(
+            "transitionCrossFade", mediaVideoItem1, mediaVideoItem2,
+            transitionDuration, transitionBehavior);
+        mVideoEditor.addTransition(transitionCrossFade);
+
+        final EffectColor effectColor = new EffectColor(mediaVideoItem1,
+            "effect", effectItemStartTime, effectItemDurationTime, effectType,
+             effectColorType);
+        mediaVideoItem1.addEffect(effectColor);
+
+        for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
+            final long duration1 = SystemClock.uptimeMillis();
+            mVideoEditor.generatePreview(new MediaProcessingProgressListener() {
+                public void onProgress(Object item, int action, int progress) {
+                }
+            });
+            final long duration2 = SystemClock.uptimeMillis();
+            mVideoEditor.removeTransition(transitionCrossFade.getId());
+            mVideoEditor.addTransition(transitionCrossFade);
+            averageDuration += (duration2 - duration1);
+        }
+        SystemClock.uptimeMillis();
+        final long durationToAddObjects = (averageDuration);
+        final float timeTaken = (float)durationToAddObjects *
+            1.0f/(float)NUM_OF_ITERATIONS;
+        loggingInfo[0] =
+            "Time taken to testPerformanceEffectOverlappingTransition\t"
+            + timeTaken;
+        writeTimingInfo("testPerformanceEffectOverlappingTransition:",
+            loggingInfo);
+    }
+
+    /**
+     * To test creation of story board with Transition and Two Effects, Effect
+     * overlapping transitions
+     *
+     * @throws Exception
+     */
+    // TODO : remove PRF_011
+    @LargeTest
+    public void testPerformanceTransitionWithEffectOverlapping() throws Exception {
+        final String videoItemFileName1 = INPUT_FILE_PATH +
+            "H264_BP_1080x720_30fps_800kbps_1_17.mp4";
+        final String videoItemFileName2 = INPUT_FILE_PATH
+            + "MPEG4_SP_640x480_15fps_512kbps_AACLC_48khz_132kbps_s_0_26.mp4";
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        final int transitionDuration = 5000;
+        final int transitionBehavior = Transition.BEHAVIOR_MIDDLE_FAST;
+        final int effectItemStartTime1 = 5000;
+        final int effectItemDurationTime1 = 5000;
+        final int effectType1 = EffectColor.TYPE_COLOR;
+        final int effectColorType1 = EffectColor.GREEN;
+        final int effectItemStartTime2 = 5000;
+        final int effectItemDurationTime2 = 5000;
+        final int effectType2 = EffectColor.TYPE_COLOR;
+        final int effectColorType2 = EffectColor.GREEN;
+        int averageTime = 0;
+        final String[] loggingInfo = new String[1];
+
+        final MediaVideoItem mediaVideoItem1 = new MediaVideoItem(mVideoEditor,
+            "mediaItem1", videoItemFileName1, renderingMode);
+        mVideoEditor.addMediaItem(mediaVideoItem1);
+
+        final MediaVideoItem mediaVideoItem2 = new MediaVideoItem(mVideoEditor,
+            "mediaItem2", videoItemFileName2, renderingMode);
+        mVideoEditor.addMediaItem(mediaVideoItem2);
+
+        final TransitionCrossfade transitionCrossFade = new TransitionCrossfade(
+            "transitionCrossFade", mediaVideoItem1, mediaVideoItem2,
+            transitionDuration, transitionBehavior);
+        mVideoEditor.addTransition(transitionCrossFade);
+
+        final EffectColor effectColor1 = new EffectColor(mediaVideoItem1,
+            "effect1", effectItemStartTime1, effectItemDurationTime1,
+            effectType1, effectColorType1);
+        mediaVideoItem1.addEffect(effectColor1);
+
+        final EffectColor effectColor2 = new EffectColor(mediaVideoItem2,
+            "effect2", effectItemStartTime2, effectItemDurationTime2,
+            effectType2, effectColorType2);
+        mediaVideoItem2.addEffect(effectColor2);
+
+        for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
+            final long duration1 = SystemClock.uptimeMillis();
+            mVideoEditor.generatePreview(new MediaProcessingProgressListener() {
+                public void onProgress(Object item, int action, int progress) {
+                }
+            });
+            final long duration2 = SystemClock.uptimeMillis();
+            mVideoEditor.removeTransition(transitionCrossFade.getId());
+            mVideoEditor.addTransition(transitionCrossFade);
+            averageTime += duration2 - duration1;
+        }
+        final long durationToAddObjects = (averageTime);
+        final float timeTaken = (float)durationToAddObjects *
+            1.0f/(float)NUM_OF_ITERATIONS;
+        loggingInfo[0] = "Time taken to TransitionWithEffectOverlapping\t"
+            + timeTaken;
+        writeTimingInfo("testPerformanceTransitionWithEffectOverlapping",
+            loggingInfo);
+    }
+
+    /**
+     *To test ThumbnailList for H264
+     */
+    // TODO : TC_PRF_12
+    @LargeTest
+    public void testThumbnailH264NonIFrame() throws Exception {
+        final String videoItemFilename = INPUT_FILE_PATH +
+            "H264_BP_1080x720_30fps_800kbps_1_17.mp4";
+        final int outWidth = 1080;
+        final int outHeight = 720;
+        final int atTime = 2400;
+        long durationToAddObjects = 0;
+        int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        final String[] loggingInfo = new String[1];
+        final MediaVideoItem mediaVideoItem = new MediaVideoItem(mVideoEditor,
+            "m1", videoItemFilename, renderingMode);
+        assertNotNull("MediaVideoItem", mediaVideoItem);
+
+        for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
+            final long duration1 = SystemClock.uptimeMillis();
+            mediaVideoItem.getThumbnail(outWidth, outHeight, atTime + i);
+            final long duration2 = SystemClock.uptimeMillis();
+            durationToAddObjects += (duration2 - duration1);
+        }
+        final float timeTaken = (float)durationToAddObjects *
+            1.0f/(float)NUM_OF_ITERATIONS;
+        loggingInfo[0] = "Time taken for Thumbnail generation \t"
+            + timeTaken;
+        writeTimingInfo("testThumbnailH264NonIFrame", loggingInfo);
+    }
+
+    /**
+     *To test ThumbnailList for H264
+     */
+    // TODO : TC_PRF_13
+    @LargeTest
+    public void testThumbnailH264AnIFrame() throws Exception {
+        final String videoItemFilename = INPUT_FILE_PATH +
+            "H264_BP_1080x720_30fps_800kbps_1_17.mp4";
+        final int outWidth = 1080;
+        final int outHeight = 720;
+        final int atTime = 3000;
+        int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        final String[] loggingInfo = new String[1];
+        long durationToAddObjects = 0;
+
+        final MediaVideoItem mediaVideoItem = new MediaVideoItem(mVideoEditor,
+            "m1", videoItemFilename, renderingMode);
+        assertNotNull("MediaVideoItem", mediaVideoItem);
+
+        for (int i = 0; i < NUM_OF_ITERATIONS; i++) {
+            final long duration1 = SystemClock.uptimeMillis();
+            mediaVideoItem.getThumbnail(outWidth, outHeight, atTime + i);
+            final long duration2 = SystemClock.uptimeMillis();
+            durationToAddObjects += (duration2 - duration1);
+        }
+        final float timeTaken = (float)durationToAddObjects *
+            1.0f/(float)NUM_OF_ITERATIONS;
+        loggingInfo[0] = "Time taken Thumbnail generation \t"
+            + timeTaken;
+        writeTimingInfo("testThumbnailH264AnIFrame", loggingInfo);
+    }
+
+    /**
+     * To test the performance : With an audio track
+     *
+     * @throws Exception
+     */
+    // TODO : remove PRF_014
+    @LargeTest
+    public void testPerformanceWithAudioTrack() throws Exception {
+        final String videoItemFileName1 = INPUT_FILE_PATH +
+            "H264_BP_1080x720_30fps_800kbps_1_17.mp4";
+        final String audioFilename1 = INPUT_FILE_PATH +
+            "AACLC_44.1kHz_256kbps_s_1_17.mp4";
+        final String audioFilename2 = INPUT_FILE_PATH +
+            "AMRNB_8KHz_12.2Kbps_m_1_17.3gp";
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        final int audioVolume = 50;
+        final String[] loggingInfo = new String[2];
+        float timeTaken = 0.0f;
+
+        final MediaVideoItem mediaVideoItem = new MediaVideoItem(mVideoEditor,
+            "mediaItem1", videoItemFileName1, renderingMode);
+        mVideoEditor.addMediaItem(mediaVideoItem);
+
+        final AudioTrack audioTrack1 = new AudioTrack(mVideoEditor,
+            "Audio Track1", audioFilename1);
+        audioTrack1.disableDucking();
+        audioTrack1.setVolume(audioVolume);
+        mVideoEditor.addAudioTrack(audioTrack1);
+
+        long beginTime = SystemClock.uptimeMillis();
+        mVideoEditor.generatePreview(new MediaProcessingProgressListener() {
+            public void onProgress(Object item, int action, int progress) {
+            }
+        });
+        timeTaken = calculateTimeTaken(beginTime, 1);
+        loggingInfo[0] = "Time taken for 1st Audio Track (AACLC)\t"
+            + timeTaken;
+
+        final AudioTrack audioTrack2 = new AudioTrack(mVideoEditor,
+            "Audio Track2", audioFilename2);
+        audioTrack2.enableLoop();
+
+        beginTime = SystemClock.uptimeMillis();
+        mVideoEditor.generatePreview(new MediaProcessingProgressListener() {
+            public void onProgress(Object item, int action, int progress) {
+            }
+        });
+        timeTaken = calculateTimeTaken(beginTime, 1);
+        loggingInfo[1] = "\n\tTime taken for 2nd Audio Track(AMRNB)\t"
+            + timeTaken;
+
+        writeTimingInfo("testPerformanceWithAudioTrack", loggingInfo);
+    }
+
+    /**
+     * To test the performance of adding and removing the
+     * image media item with 640 x 480
+     *
+     * @throws Exception
+     */
+    // TODO : remove PRF_015
+    @LargeTest
+    public void testPerformanceAddRemoveImageItem640x480() throws Exception {
+        final String imageItemFileName = INPUT_FILE_PATH + "IMG_640x480.jpg";
+        final int imageItemDuration = 0;
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        final String[] loggingInfo = new String[3];
+
+        float timeTaken = 0.0f;
+
+        final MediaImageItem[] mediaImageItem =
+            new MediaImageItem[NUM_OF_ITERATIONS];
+        long beginTime = SystemClock.uptimeMillis();
+        createImageItems(mediaImageItem, imageItemFileName, renderingMode,
+            imageItemDuration);
+        timeTaken = calculateTimeTaken(beginTime, NUM_OF_ITERATIONS);
+        loggingInfo[0] = "Time taken to Create  Media Image Item (640x480)\t"
+            + timeTaken;
+
+        beginTime = SystemClock.uptimeMillis();
+        addImageItems(mediaImageItem);
+        timeTaken = calculateTimeTaken(beginTime, NUM_OF_ITERATIONS);
+        loggingInfo[1] = "\n\tTime taken to add  Media Image Item (640x480)\t"
+            + timeTaken;
+
+        beginTime = SystemClock.uptimeMillis();
+        removeImageItems(mediaImageItem);
+        timeTaken = calculateTimeTaken(beginTime, NUM_OF_ITERATIONS);
+        loggingInfo[2] = "\n\tTime taken to remove  Media Image Item (640x480)\t"
+            + timeTaken;
+        writeTimingInfo("testPerformanceAddRemoveImageItem640x480 (in mSec)", loggingInfo);
+    }
+
+
+}
diff --git a/media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/stress/VideoEditorStressTest.java b/media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/stress/VideoEditorStressTest.java
new file mode 100755
index 0000000..7563a55
--- /dev/null
+++ b/media/tests/MediaFrameworkTest/src/com/android/mediaframeworktest/stress/VideoEditorStressTest.java
@@ -0,0 +1,1682 @@
+/*
+ * Copyright (C) 2011 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.
+ */
+
+package com.android.mediaframeworktest.stress;
+
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.FileWriter;
+import java.io.Writer;
+import java.util.List;
+
+import android.graphics.Bitmap;
+import android.graphics.Rect;
+import android.media.videoeditor.AudioTrack;
+import android.media.videoeditor.EffectColor;
+import android.media.videoeditor.EffectKenBurns;
+import android.media.videoeditor.MediaImageItem;
+import android.media.videoeditor.MediaItem;
+import android.media.videoeditor.MediaProperties;
+import android.media.videoeditor.MediaVideoItem;
+import android.media.videoeditor.OverlayFrame;
+import android.media.videoeditor.Transition;
+import android.media.videoeditor.TransitionCrossfade;
+import android.media.videoeditor.TransitionAlpha;
+import android.media.videoeditor.TransitionFadeBlack;
+import android.media.videoeditor.TransitionSliding;
+import android.media.videoeditor.VideoEditor;
+import android.os.Environment;
+import android.test.ActivityInstrumentationTestCase;
+import android.media.videoeditor.VideoEditor.MediaProcessingProgressListener;
+import android.os.Environment;
+import android.os.SystemClock;
+import android.test.ActivityInstrumentationTestCase;
+import android.media.videoeditor.VideoEditor.ExportProgressListener;
+import android.media.videoeditor.VideoEditorFactory;
+import android.media.videoeditor.ExtractAudioWaveformProgressListener;
+
+import android.os.Debug;
+import android.util.Log;
+
+import com.android.mediaframeworktest.MediaFrameworkTest;
+import android.test.suitebuilder.annotation.LargeTest;
+import com.android.mediaframeworktest.VideoEditorHelper;
+
+/**
+ * Junit / Instrumentation - performance measurement for media player and
+ * recorder
+ */
+public class VideoEditorStressTest
+        extends ActivityInstrumentationTestCase<MediaFrameworkTest> {
+
+    private final String TAG = "VideoEditorPerformance";
+
+    private final String PROJECT_LOCATION = VideoEditorHelper.PROJECT_LOCATION_COMMON;
+
+    private final String INPUT_FILE_PATH = VideoEditorHelper.INPUT_FILE_PATH_COMMON;
+
+
+    private final String VIDEOEDITOR_OUTPUT = PROJECT_LOCATION +
+        "VideoEditorStressMemOutput.txt";
+
+    public VideoEditorStressTest() {
+        super("com.android.mediaframeworktest", MediaFrameworkTest.class);
+        new File(VIDEOEDITOR_OUTPUT).delete();
+    }
+
+    private final String PROJECT_CLASS_NAME =
+        "android.media.videoeditor.VideoEditorImpl";
+    private VideoEditor mVideoEditor;
+    private VideoEditorHelper mVideoEditorHelper;
+
+    @Override
+    protected void setUp() throws Exception {
+        // setup for each test case.
+        super.setUp();
+        mVideoEditorHelper = new VideoEditorHelper();
+        // Create a random String which will be used as project path, where all
+        // project related files will be stored.
+        final String projectPath =
+            mVideoEditorHelper.createRandomFile(PROJECT_LOCATION);
+        mVideoEditor = mVideoEditorHelper.createVideoEditor(projectPath);
+    }
+
+    @Override
+    protected void tearDown() throws Exception {
+        mVideoEditorHelper.destroyVideoEditor(mVideoEditor);
+        // Clean the directory created as project path
+        mVideoEditorHelper.deleteProject(new File(mVideoEditor.getPath()));
+        System.gc();
+        super.tearDown();
+    }
+
+    private void writeTimingInfo(String testCaseName, String[] information)
+        throws Exception {
+        File outFile = new File(VIDEOEDITOR_OUTPUT);
+        Writer output = new BufferedWriter(new FileWriter(outFile, true));
+        output.write(testCaseName + "\n\t");
+        for (int i = 0; i < information.length; i++) {
+            output.write(information[i]);
+        }
+        output.write("\n\n");
+        output.close();
+    }
+
+    /**
+     * To stress test MediaItem(Video Item) adding functionality
+     *
+     * @throws Exception
+     */
+    // TODO : remove TC_STR_001
+    @LargeTest
+    public void testStressAddRemoveVideoItem() throws Exception {
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+
+        final String videoItemFileName1 = INPUT_FILE_PATH +
+            "H264_BP_176x144_15fps_144kbps_AMRNB_8kHz_12.2kbps_m_1_17.3gp";
+        final String videoItemFileName2 = INPUT_FILE_PATH +
+            "MPEG4_SP_720x480_30fps_280kbps_AACLC_48kHz_96kbps_s_0_21.mp4";
+        final String videoItemFileName3 = INPUT_FILE_PATH +
+            "H263_profile0_176x144_15fps_128kbps_1_35.3gp";
+        final String videoItemFileName4 = INPUT_FILE_PATH +
+            "MPEG4_SP_640x480_15fps_1200kbps_AACLC_48khz_64kbps_m_1_17.3gp";
+        final String[] loggingInfo = new String[4];
+
+        // Take snapShot of Java and Native Memory, do a GC
+        System.gc();
+        final Runtime runtimeObjStart = Runtime.getRuntime();
+        final long javaMemStart = runtimeObjStart.totalMemory();
+        final long nativeMemStart = Debug.getNativeHeapAllocatedSize();
+        for (int i = 0; i < 50; i++) {
+            if (i % 4 == 0) {
+                final MediaVideoItem mediaItem1 = new MediaVideoItem(mVideoEditor,
+                    "m1" + i, videoItemFileName1, renderingMode);
+                mediaItem1.setExtractBoundaries(0, 5000);
+                mVideoEditor.addMediaItem(mediaItem1);
+            }
+            if (i % 4 == 1) {
+                final MediaVideoItem mediaItem2 = new MediaVideoItem(mVideoEditor,
+                    "m2" + i, videoItemFileName2, renderingMode);
+                mediaItem2.setExtractBoundaries(0, 10000);
+                mVideoEditor.addMediaItem(mediaItem2);
+            }
+            if (i % 4 == 2) {
+                final MediaVideoItem mediaItem3 = new MediaVideoItem(mVideoEditor,
+                    "m3" + i, videoItemFileName3, renderingMode);
+                mediaItem3.setExtractBoundaries(30000, 45000);
+                mVideoEditor.addMediaItem(mediaItem3);
+            }
+            if (i % 4 == 3) {
+                final MediaVideoItem mediaItem4 = new MediaVideoItem(mVideoEditor,
+                    "m4" + i, videoItemFileName4, renderingMode);
+                mediaItem4.setExtractBoundaries(10000, 30000);
+                mVideoEditor.addMediaItem(mediaItem4);
+            }
+        }
+        // We will sleep for some time & do an Explicit GC, So that we can get
+        // real memory snapshot
+        System.gc();
+        Thread.sleep(2500);
+        final Runtime runtimeObjEnd = Runtime.getRuntime();
+        final long javaMemEnd = runtimeObjEnd.totalMemory();
+        final long nativeMemEnd = Debug.getNativeHeapAllocatedSize();
+        loggingInfo[0] = "\nJava Memory at Start = " + javaMemStart +
+            "\n\tJava Memory at End = " + javaMemEnd +
+            "\n\tJava Memory (End - Start) = " + (javaMemEnd - javaMemStart);
+        loggingInfo[1] = "\nNative Memory at Start = " + nativeMemStart +
+            "\n\tNative Memory at End = " + nativeMemEnd +
+            "\n\tNative Memory (End-Start)= " + (nativeMemEnd - nativeMemStart);
+
+        /** Remove items and check for memory leak if any */
+        // Take snapShot of Java and Native Memory, do a GC
+        System.gc();
+        final Runtime runtimeObjStart1 = Runtime.getRuntime();
+        final long javaMemStart1 = runtimeObjStart.totalMemory();
+        final long nativeMemStart1 = Debug.getNativeHeapAllocatedSize();
+        for (int i = 0; i < 50; i++) {
+            if (i % 4 == 0) {
+                mVideoEditor.removeMediaItem("m1" + i);
+            }
+            if (i % 4 == 1) {
+                mVideoEditor.removeMediaItem("m2" + i);
+            }
+            if (i % 4 == 2) {
+                mVideoEditor.removeMediaItem("m3" + i);
+            }
+            if (i % 4 == 3) {
+                mVideoEditor.removeMediaItem("m4" + i);
+            }
+        }
+        // We will sleep for some time & do an Explicit GC, So that we can get
+        // real memory snapshot
+        System.gc();
+        Thread.sleep(2500);
+        final Runtime runtimeObjEnd1 = Runtime.getRuntime();
+        final long javaMemEnd1 = runtimeObjEnd.totalMemory();
+        final long nativeMemEnd1 = Debug.getNativeHeapAllocatedSize();
+        loggingInfo[2] = "\nAfter Items remvoed:\nJava Memory at Start = " +
+            javaMemStart1 + "\n\tJava Memory at End = " + javaMemEnd1 +
+            "\n\tJava Memory (End - Start) = " + (javaMemEnd1 - javaMemStart1);
+        loggingInfo[3] = "\nNative Memory at Start = " + nativeMemStart1 +
+            "\n\tNative Memory at End = " + nativeMemEnd1 +
+            "\n\tNative Memory (End-Start)= " + (nativeMemEnd1 - nativeMemStart1);
+
+        writeTimingInfo("testStressAddRemoveVideoItem", loggingInfo);
+    }
+
+    /**
+     * To stress test MediaItem(Image Item) adding functionality
+     *
+     * @throws Exception
+     */
+    // TODO : remove TC_STR_002
+    @LargeTest
+    public void testStressAddRemoveImageItem() throws Exception {
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        final String ImageItemFileName1 = INPUT_FILE_PATH +
+            "IMG_1600x1200.jpg";
+        final String ImageItemFileName2 = INPUT_FILE_PATH +
+            "IMG_640x480.jpg";
+        final String ImageItemFileName3 = INPUT_FILE_PATH +
+            "IMG_320x240.jpg";
+        final String ImageItemFileName4 = INPUT_FILE_PATH +
+            "IMG_176x144.jpg";
+        final String[] loggingInfo = new String[4];
+
+        // Take snapShot of Java and Native Memory, do a GC
+        System.gc();
+        final Runtime runtimeObjStart = Runtime.getRuntime();
+        final long javaMemStart = runtimeObjStart.totalMemory();
+        final long nativeMemStart = Debug.getNativeHeapAllocatedSize();
+        for (int i = 0; i < 500; i++) {
+            if (i % 4 == 0) {
+                final MediaImageItem mediaItem1 = new MediaImageItem(mVideoEditor,
+                    "m1"+ i, ImageItemFileName1, 5000, renderingMode);
+                mVideoEditor.addMediaItem(mediaItem1);
+            }
+            if (i % 4 == 1) {
+                final MediaImageItem mediaItem2 = new MediaImageItem(mVideoEditor,
+                    "m2"+ i, ImageItemFileName2, 10000, renderingMode);
+                mVideoEditor.addMediaItem(mediaItem2);
+            }
+            if (i % 4 == 2) {
+                final MediaImageItem mediaItem3 = new MediaImageItem(mVideoEditor,
+                    "m3"+ i, ImageItemFileName3, 15000, renderingMode);
+                mVideoEditor.addMediaItem(mediaItem3);
+            }
+            if (i % 4 == 3) {
+                final MediaImageItem mediaItem4 = new MediaImageItem(mVideoEditor,
+                    "m4"+ i, ImageItemFileName4, 20000, renderingMode);
+                mVideoEditor.addMediaItem(mediaItem4);
+            }
+        }
+        // We will sleep for some time & do an Explicit GC, So that we can get
+        // real memory snapshot
+        System.gc();
+        Thread.sleep(2500);
+        final Runtime runtimeObjEnd = Runtime.getRuntime();
+        final long javaMemEnd = runtimeObjEnd.totalMemory();
+        final long nativeMemEnd = Debug.getNativeHeapAllocatedSize();
+        loggingInfo[0] = "Java Memory at Start = " + javaMemStart +
+            "\n\tJava Memory at End = " + javaMemEnd +
+            "\n\tJava Memory (End - Start) = " + (javaMemEnd - javaMemStart);
+        loggingInfo[1] = "Native Memory at Start = " + nativeMemStart +
+            "\n\tNative Memory at End = " + nativeMemEnd +
+            "\n\tNative Memory (End-Start) = " + (nativeMemEnd - nativeMemStart);
+
+        /** Remove items and check for memory leak if any */
+        // Take snapShot of Java and Native Memory, do a GC
+        System.gc();
+        final Runtime runtimeObjStart1 = Runtime.getRuntime();
+        final long javaMemStart1 = runtimeObjStart.totalMemory();
+        final long nativeMemStart1 = Debug.getNativeHeapAllocatedSize();
+        for (int i = 0; i < 500; i++) {
+            if (i % 4 == 0) {
+                mVideoEditor.removeMediaItem("m1"+i);
+            }
+            if (i % 4 == 1) {
+                mVideoEditor.removeMediaItem("m2"+i);
+            }
+            if (i % 4 == 2) {
+                mVideoEditor.removeMediaItem("m3"+i);
+            }
+            if (i % 4 == 3) {
+                mVideoEditor.removeMediaItem("m4"+i);
+            }
+        }
+        // We will sleep for some time & do an Explicit GC, So that we can get
+        // real memory snapshot
+        System.gc();
+        Thread.sleep(2500);
+        final Runtime runtimeObjEnd1 = Runtime.getRuntime();
+        final long javaMemEnd1 = runtimeObjEnd.totalMemory();
+        final long nativeMemEnd1 = Debug.getNativeHeapAllocatedSize();
+        loggingInfo[2] = "\nAfter removal:\nJava Memory at Start = " +
+            javaMemStart1 + "\n\tJava Memory at End = " + javaMemEnd1 +
+            "\n\tJava Memory (End - Start) = " + (javaMemEnd1 - javaMemStart1);
+        loggingInfo[3] = "Native Memory at Start = " + nativeMemStart1 +
+            "\n\tNative Memory at End = " + nativeMemEnd1 +
+            "\n\tNative Memory (End-Start) = " + (nativeMemEnd1 - nativeMemStart1);
+
+        writeTimingInfo("testStressAddRemoveImageItem", loggingInfo);
+    }
+
+    /**
+     * To stress test transition
+     *
+     * @throws Exception
+     */
+    // TODO : remove TC_STR_003
+    @LargeTest
+    public void testStressAddRemoveTransition() throws Exception {
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        final String VideoItemFileName1 = INPUT_FILE_PATH +
+            "H264_BP_800x480_15fps_512kbps_1_17.mp4";
+        final String ImageItemFileName2 = INPUT_FILE_PATH +
+            "IMG_1600x1200.jpg";
+        final String VideoItemFileName3 = INPUT_FILE_PATH +
+            "MPEG4_SP_640x480_15fps_512kbps_AACLC_48khz_132kbps_s_0_26.mp4";
+        final String maskFilename = INPUT_FILE_PATH +
+            "TransitionSpiral_QVGA.jpg";
+        final String[] loggingInfo = new String[4];
+
+        // Take snapShot of Java and Native Memory, do a GC
+        System.gc();
+        final Runtime runtimeObjStart = Runtime.getRuntime();
+        final long javaMemStart = runtimeObjStart.totalMemory();
+        final long nativeMemStart = Debug.getNativeHeapAllocatedSize();
+        for (int i = 0; i < 50; i++) {
+            if (i % 4 == 0) {
+                final MediaVideoItem mediaItem1 = new MediaVideoItem(mVideoEditor,
+                    "m1"+i, VideoItemFileName1, renderingMode);
+                mVideoEditor.addMediaItem(mediaItem1);
+                mediaItem1.setExtractBoundaries(0, 10000);
+                final TransitionCrossfade tranCrossfade =
+                    new TransitionCrossfade("transCF" + i, null,
+                        mediaItem1, 5000, Transition.BEHAVIOR_MIDDLE_FAST);
+                mVideoEditor.addTransition(tranCrossfade);
+            }
+            if (i % 4 == 1) {
+                final MediaVideoItem mediaItem1 = new MediaVideoItem(mVideoEditor,
+                    "m1"+i, VideoItemFileName1, renderingMode);
+                mVideoEditor.addMediaItem(mediaItem1);
+                mediaItem1.setExtractBoundaries(0, 10000);
+
+                final MediaImageItem mediaItem2 = new MediaImageItem(mVideoEditor,
+                    "m2" +i, ImageItemFileName2, 10000, renderingMode);
+                mVideoEditor.addMediaItem(mediaItem2);
+
+                final TransitionAlpha transitionAlpha =
+                    mVideoEditorHelper.createTAlpha("transAlpha" + i, mediaItem1,
+                        mediaItem2, 5000, Transition.BEHAVIOR_SPEED_UP,
+                        maskFilename, 10, false);
+                transitionAlpha.setDuration(4000);
+                mVideoEditor.addTransition(transitionAlpha);
+            }
+            if (i % 4 == 2) {
+                final MediaImageItem mediaItem2 = new MediaImageItem(mVideoEditor,
+                    "m2" + i, ImageItemFileName2, 10000, renderingMode);
+                mVideoEditor.addMediaItem(mediaItem2);
+
+                final MediaVideoItem mediaItem3 = new MediaVideoItem(mVideoEditor,
+                    "m3" + i, VideoItemFileName3, renderingMode);
+                mVideoEditor.addMediaItem(mediaItem3);
+
+                mediaItem3.setExtractBoundaries(0, 10000);
+                final TransitionAlpha transitionAlpha =
+                    mVideoEditorHelper.createTAlpha("transAlpha" + i, mediaItem2,
+                        mediaItem3, 5000, Transition.BEHAVIOR_SPEED_UP,
+                        maskFilename, 10, false);
+                transitionAlpha.setDuration(4000);
+                mVideoEditor.addTransition(transitionAlpha);
+
+                mediaItem3.setExtractBoundaries(0, 6000);
+
+                final TransitionSliding transition2And3 =
+                    mVideoEditorHelper.createTSliding("transSlide" +i, mediaItem2,
+                        mediaItem3, 3000, Transition.BEHAVIOR_MIDDLE_FAST,
+                        TransitionSliding.DIRECTION_LEFT_OUT_RIGHT_IN);
+                mVideoEditor.addTransition(transition2And3);
+            }
+            if (i % 4 == 3) {
+                final MediaVideoItem mediaItem3 = new MediaVideoItem(mVideoEditor,
+                    "m3" + i, VideoItemFileName3, renderingMode);
+                mVideoEditor.addMediaItem(mediaItem3);
+                mediaItem3.setExtractBoundaries(0, 5000);
+
+                final TransitionFadeBlack transition3 =
+                    mVideoEditorHelper.createTFadeBlack("transFB" +i, mediaItem3,
+                        null, 2500, Transition.BEHAVIOR_SPEED_UP);
+                transition3.setDuration(500);
+                mVideoEditor.addTransition(transition3);
+            }
+        }
+        // We will sleep for some time & do an Explicit GC, So that we can get
+        // real memory snapshot
+        System.gc();
+        Thread.sleep(2500);
+        final Runtime runtimeObjEnd = Runtime.getRuntime();
+        final long javaMemEnd = runtimeObjEnd.totalMemory();
+        final long nativeMemEnd = Debug.getNativeHeapAllocatedSize();
+        loggingInfo[0] = "Java Memory at Start = " + javaMemStart +
+            "\n\tJava Memory at End = " + javaMemEnd +
+            "\n\tJava Memory (End - Start) = " + (javaMemEnd - javaMemStart);
+        loggingInfo[1] = "Native Memory at Start = " + nativeMemStart +
+            "\n\tNative Memory at End = " + nativeMemEnd +
+            "\n\tNative Memory (End-Start) = " + (nativeMemEnd - nativeMemStart);
+
+        /** Remove items and check for memory leak if any */
+        // Take snapShot of Java and Native Memory, do a GC
+        System.gc();
+        final Runtime runtimeObjStart1 = Runtime.getRuntime();
+        final long javaMemStart1 = runtimeObjStart.totalMemory();
+        final long nativeMemStart1 = Debug.getNativeHeapAllocatedSize();
+        for (int i = 0; i < 50; i++) {
+            if (i % 4 == 0) {
+                mVideoEditor.removeTransition("transCF" + i);
+                mVideoEditor.removeMediaItem("m1" + i);
+            }
+            if (i % 4 == 1) {
+                mVideoEditor.removeTransition("transAlpha" + i);
+                mVideoEditor.removeMediaItem("m1" + i);
+                mVideoEditor.removeMediaItem("m2" + i);
+            }
+            if (i % 4 == 2) {
+                /* Because transition is overrid */
+//                mVideoEditor.removeTransition("transAlpha" + i);
+                mVideoEditor.removeTransition("transSlide" +i);
+                mVideoEditor.removeMediaItem("m2" + i);
+                mVideoEditor.removeMediaItem("m3" + i);
+            }
+            if (i % 4 == 3) {
+//                mVideoEditor.removeTransition("transFB" +i);
+                mVideoEditor.removeMediaItem("m3" + i);
+            }
+        }
+        // We will sleep for some time & do an Explicit GC, So that we can get
+        // real memory snapshot
+        System.gc();
+        Thread.sleep(2500);
+        final Runtime runtimeObjEnd1 = Runtime.getRuntime();
+        final long javaMemEnd1 = runtimeObjEnd.totalMemory();
+        final long nativeMemEnd1 = Debug.getNativeHeapAllocatedSize();
+        loggingInfo[2] = "\nAfter removal:\nJava Memory at Start = " +
+            javaMemStart1 + "\n\tJava Memory at End = " + javaMemEnd1 +
+            "\n\tJava Memory (End - Start) = " + (javaMemEnd1 - javaMemStart1);
+        loggingInfo[3] = "Native Memory at Start = " + nativeMemStart1 +
+            "\n\tNative Memory at End = " + nativeMemEnd1 +
+            "\n\tNative Memory (End-Start) = " + (nativeMemEnd1 - nativeMemStart1);
+
+        writeTimingInfo("testStressAddRemoveTransition", loggingInfo);
+    }
+
+    /**
+     * To stress test overlay
+     *
+     * @throws Exception
+     */
+    // TODO : remove TC_STR_004
+    @LargeTest
+    public void testStressAddRemoveOverlay() throws Exception {
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        final String VideoItemFileName1 = INPUT_FILE_PATH +
+            "MPEG4_SP_640x480_15fps_512kbps_AACLC_48khz_132kbps_s_0_26.mp4";
+        final String ImageItemFileName2 = INPUT_FILE_PATH +
+            "IMG_640x480.jpg";
+        final String OverlayFile3 = INPUT_FILE_PATH +
+            "IMG_640x480_Overlay1.png";
+        final String OverlayFile4 = INPUT_FILE_PATH +
+            "IMG_640x480_Overlay2.png";
+        final String[] loggingInfo = new String[2];
+
+        final MediaVideoItem mediaItem1 = new MediaVideoItem(mVideoEditor,
+            "m1", VideoItemFileName1, renderingMode);
+        mVideoEditor.addMediaItem(mediaItem1);
+
+        final MediaImageItem mediaItem2 = new MediaImageItem(mVideoEditor,
+            "m2", ImageItemFileName2, 10000, renderingMode);
+        mVideoEditor.addMediaItem(mediaItem2);
+
+        // Take snapShot of Java and Native Memory, do a GC
+        System.gc();
+        final Runtime runtimeObjStart = Runtime.getRuntime();
+        final long javaMemStart = runtimeObjStart.totalMemory();
+        final long nativeMemStart = Debug.getNativeHeapAllocatedSize();
+        for (int i = 0; i < 50; i++) {
+            if (i % 3 == 0) {
+                mediaItem1.setExtractBoundaries(0, 10000);
+                final Bitmap mBitmap =  mVideoEditorHelper.getBitmap(
+                    OverlayFile3, 640, 480);
+                final OverlayFrame overlayFrame =
+                    mVideoEditorHelper.createOverlay(mediaItem1, "overlay" + i,
+                        mBitmap, 1000, 5000);
+                mediaItem1.addOverlay(overlayFrame);
+                mediaItem1.removeOverlay("overlay"+i);
+            }
+            if (i % 3 == 1) {
+                final Bitmap mBitmap =  mVideoEditorHelper.getBitmap(
+                    OverlayFile4, 640, 480);
+                final OverlayFrame overlayFrame =
+                    mVideoEditorHelper.createOverlay(mediaItem2, "overlay" + i,
+                        mBitmap, 1000, 5000);
+                mediaItem2.addOverlay(overlayFrame);
+                mediaItem2.removeOverlay("overlay"+i);
+            }
+            if (i % 3 == 2) {
+                mediaItem1.setExtractBoundaries(0, 10000);
+                final Bitmap mBitmap =  mVideoEditorHelper.getBitmap(
+                    OverlayFile4, 640, 480);
+                final OverlayFrame overlayFrame =
+                    mVideoEditorHelper.createOverlay(mediaItem1, "overlay" + i,
+                        mBitmap, 0, mediaItem1.getDuration());
+                mediaItem1.addOverlay(overlayFrame);
+                mediaItem1.removeOverlay("overlay"+i);
+            }
+        }
+        // We will sleep for some time & do an Explicit GC, So that we can get
+        // real memory snapshot
+        System.gc();
+        Thread.sleep(2500);
+        final Runtime runtimeObjEnd = Runtime.getRuntime();
+        final long javaMemEnd = runtimeObjEnd.totalMemory();
+        final long nativeMemEnd = Debug.getNativeHeapAllocatedSize();
+        loggingInfo[0] = "Java Memory at Start = " + javaMemStart +
+            "\n\tJava Memory at End = " + javaMemEnd +
+            "\n\tJava Memory (End - Start) = " + (javaMemEnd - javaMemStart);
+        loggingInfo[1] = "Native Memory at Start = " + nativeMemStart +
+            "\n\tNative Memory at End = " + nativeMemEnd +
+            "\n\tNative Memory (End-Start) = " + (nativeMemEnd - nativeMemStart);
+        writeTimingInfo("testStressAddRemoveOverlay", loggingInfo);
+    }
+
+    /**
+     * To stress test Effects
+     *
+     * @throws Exception
+     */
+    // TODO : remove TC_STR_005
+    @LargeTest
+    public void testStressAddRemoveEffects() throws Exception {
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        final String VideoItemFileName1 = INPUT_FILE_PATH +
+            "MPEG4_SP_640x480_15fps_1200kbps_AACLC_48khz_64kbps_m_1_17.3gp";
+        final String ImageItemFileName2 = INPUT_FILE_PATH +
+            "IMG_1600x1200.jpg";
+
+        final String[] loggingInfo = new String[4];
+
+        final MediaVideoItem mediaItem1 = new MediaVideoItem(mVideoEditor,
+            "m1", VideoItemFileName1, renderingMode);
+        mVideoEditor.addMediaItem(mediaItem1);
+
+        final MediaImageItem mediaItem2 = new MediaImageItem(mVideoEditor,
+            "m2", ImageItemFileName2, 10000, renderingMode);
+        mVideoEditor.addMediaItem(mediaItem2);
+
+        // Take snapShot of Java and Native Memory, do a GC
+        System.gc();
+        final Runtime runtimeObjStart = Runtime.getRuntime();
+        final long javaMemStart = runtimeObjStart.totalMemory();
+        final long nativeMemStart = Debug.getNativeHeapAllocatedSize();
+        for (int i = 0; i < 500; i++) {
+            if (i % 5 == 0) {
+                mediaItem1.setExtractBoundaries(10000, 30000);
+                final EffectColor effectColor1 =
+                    mVideoEditorHelper.createEffectItem(mediaItem1, "effect1"+i,
+                        10000, (mediaItem1.getTimelineDuration()-1000),
+                        EffectColor.TYPE_COLOR, EffectColor.GREEN);
+                mediaItem1.addEffect(effectColor1);
+            }
+            if (i % 5 == 1) {
+                mediaItem2.setDuration(20000);
+                final EffectColor effectColor1 =
+                    mVideoEditorHelper.createEffectItem(mediaItem2, "effect1"+i,
+                        0, 4000, EffectColor.TYPE_GRADIENT, EffectColor.GRAY);
+                mediaItem2.addEffect(effectColor1);
+            }
+            if (i % 5 == 2) {
+                mediaItem1.setExtractBoundaries(10000, 30000);
+                final EffectColor effectColor1 =
+                    mVideoEditorHelper.createEffectItem(mediaItem1, "effect1"+i,
+                        (mediaItem1.getTimelineDuration() - 4000), 4000,
+                        EffectColor.TYPE_SEPIA, 0);
+                mediaItem1.addEffect(effectColor1);
+            }
+            if (i % 5 == 3) {
+                mediaItem2.setDuration(20000);
+                final EffectColor effectColor1 =
+                    mVideoEditorHelper.createEffectItem(mediaItem2, "effect1"+i,
+                        10000, 4000, EffectColor.TYPE_NEGATIVE, 0);
+                mediaItem2.addEffect(effectColor1);
+            }
+            if (i % 5 == 4) {
+                mediaItem2.setDuration(20000);
+                final Rect startRect = new Rect((mediaItem2.getHeight() / 3),
+                    (mediaItem2.getWidth() / 3), (mediaItem2.getHeight() / 2),
+                    (mediaItem2.getWidth() / 2));
+                final Rect endRect = new Rect(0, 0, mediaItem2.getWidth(),
+                    mediaItem2.getHeight());
+                final EffectKenBurns kbEffectOnMediaItem = new EffectKenBurns(
+                    mediaItem2, "KBOnM2" + i, startRect, endRect, 500,
+                    (mediaItem2.getDuration() - 500));
+                mediaItem2.addEffect(kbEffectOnMediaItem);
+            }
+        }
+        // We will sleep for some time & do an Explicit GC, So that we can get
+        // real memory snapshot
+        System.gc();
+        Thread.sleep(2500);
+        final Runtime runtimeObjEnd = Runtime.getRuntime();
+        final long javaMemEnd = runtimeObjEnd.totalMemory();
+        final long nativeMemEnd = Debug.getNativeHeapAllocatedSize();
+        loggingInfo[0] = "Java Memory at Start = " + javaMemStart +
+            "\n\tJava Memory at End = " + javaMemEnd +
+            "\n\tJava Memory (End - Start) = " + (javaMemEnd - javaMemStart);
+        loggingInfo[1] = "Native Memory at Start = " + nativeMemStart +
+            "\n\tNative Memory at End = " + nativeMemEnd +
+            "\n\tNative Memory (End-Start) = " + (nativeMemEnd - nativeMemStart);
+
+        /** Remove items and check for memory leak if any */
+        // Take snapShot of Java and Native Memory, do a GC
+        System.gc();
+        final Runtime runtimeObjStart1 = Runtime.getRuntime();
+        final long javaMemStart1 = runtimeObjStart.totalMemory();
+        final long nativeMemStart1 = Debug.getNativeHeapAllocatedSize();
+        for (int i = 0; i < 500; i++) {
+            if (i % 5 == 0) {
+                mediaItem1.removeEffect("effect1"+i);
+            }
+            if (i % 5 == 1) {
+                mediaItem1.removeEffect("effect1"+i);
+            }
+            if (i % 5 == 2) {
+                mediaItem1.removeEffect("effect1"+i);
+            }
+            if (i % 5 == 3) {
+                mediaItem1.removeEffect("effect1"+i);
+            }
+            if (i % 5 == 4) {
+                mediaItem1.removeEffect("KBOnM2"+i);
+            }
+        }
+        // We will sleep for some time & do an Explicit GC, So that we can get
+        // real memory snapshot
+        System.gc();
+        Thread.sleep(2500);
+        final Runtime runtimeObjEnd1 = Runtime.getRuntime();
+        final long javaMemEnd1 = runtimeObjEnd.totalMemory();
+        final long nativeMemEnd1 = Debug.getNativeHeapAllocatedSize();
+        loggingInfo[2] = "\nAfter removal:\nJava Memory at Start = " +
+            javaMemStart1 + "\n\tJava Memory at End = " + javaMemEnd1 +
+            "\n\tJava Memory (End - Start) = " + (javaMemEnd1 - javaMemStart1);
+        loggingInfo[3] = "Native Memory at Start = " + nativeMemStart1 +
+            "\n\tNative Memory at End = " + nativeMemEnd1 +
+            "\n\tNative Memory (End-Start)= " + (nativeMemEnd1 - nativeMemStart1);
+
+        writeTimingInfo("testStressAddRemoveEffects", loggingInfo);
+    }
+
+    /**
+     * This method will test thumbnail list extraction in a loop = 200 for Video
+     * Item
+     *
+     * @throws Exception
+     */
+    // TODO : remove TC_STR_006
+    @LargeTest
+    public void testStressThumbnailVideoItem() throws Exception {
+        final String videoItemFileName = INPUT_FILE_PATH
+                + "H264_BP_640x480_15fps_1200Kbps_AACLC_48KHz_64kps_m_0_27.3gp";
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        final String[] loggingInfo = new String[2];
+
+        final MediaVideoItem mediaVideoItem = new MediaVideoItem(mVideoEditor,
+            "m1", videoItemFileName, renderingMode);
+        // Take snapShot of Java and Native Memory, do a GC
+        System.gc();
+        final Runtime runtimeObjStart = Runtime.getRuntime();
+        final long javaMemStart = runtimeObjStart.totalMemory();
+        final long nativeMemStart = Debug.getNativeHeapAllocatedSize();
+
+        for (int i = 0; i < 50; i++) {
+            if (i % 4 == 0) {
+                final Bitmap[] thumbNails =
+                    mediaVideoItem.getThumbnailList(mediaVideoItem.getWidth()*3,
+                        mediaVideoItem.getHeight()*2, i, 5000, 2);
+                // Recycle this Bitmap array
+                for (int i1 = 0; i1 < thumbNails.length; i1++) {
+                    thumbNails[i1].recycle();
+                }
+            }
+            if (i % 4 == 1) {
+                final Bitmap[] thumbNails =
+                    mediaVideoItem.getThumbnailList(mediaVideoItem.getWidth()/2,
+                        mediaVideoItem.getHeight() * 3, i, 5000, 2);
+                // Recycle this Bitmap array
+                for (int i1 = 0; i1 < thumbNails.length; i1++) {
+                    thumbNails[i1].recycle();
+                }
+            }
+            if (i % 4 == 2) {
+                final Bitmap[] thumbNails =
+                    mediaVideoItem.getThumbnailList(mediaVideoItem.getWidth()*2,
+                        mediaVideoItem.getHeight() / 3, i, 5000, 2);
+                // Recycle this Bitmap array
+                for (int i1 = 0; i1 < thumbNails.length; i1++) {
+                    thumbNails[i1].recycle();
+                }
+            }
+            if (i % 4 == 3) {
+                final Bitmap[] thumbNails =
+                    mediaVideoItem.getThumbnailList(mediaVideoItem.getWidth(),
+                        mediaVideoItem.getHeight(), i, 5000, 2);
+                // Recycle this Bitmap array
+                for (int i1 = 0; i1 < thumbNails.length; i1++) {
+                    thumbNails[i1].recycle();
+                }
+            }
+        }
+        // We will sleep for some time & do an Explicit GC, So that we can get
+        // real memory snapshot
+        System.gc();
+        Thread.sleep(2500);
+        final Runtime runtimeObjEnd = Runtime.getRuntime();
+        final long javaMemEnd = runtimeObjEnd.totalMemory();
+        final long nativeMemEnd = Debug.getNativeHeapAllocatedSize();
+        loggingInfo[0] = "Java Memory at Start = " + javaMemStart +
+            "\t\tJava Memory at End = " + javaMemEnd +
+            "\t\tJava Memory (End - Start) = " + (javaMemEnd - javaMemStart);
+        loggingInfo[1] = "Native Memory at Start = " + nativeMemStart +
+            "\tNative Memory at End = " + nativeMemEnd +
+            "\t\tNative Memory (End-Start) = " + (nativeMemEnd - nativeMemStart);
+        writeTimingInfo("testStressThumbnailVideoItem", loggingInfo);
+    }
+
+
+
+    /**
+     * To stress test media properties
+     *
+     * @throws Exception
+     */
+    // TODO : remove TC_STR_007
+    @LargeTest
+    public void testStressMediaProperties() throws Exception {
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        final String VideoItemFileName1 = INPUT_FILE_PATH +
+            "H264_BP_1080x720_30fps_800kbps_1_17.mp4";
+        final String ImageItemFileName2 = INPUT_FILE_PATH +
+            "IMG_640x480.jpg";
+        final String AudioItemFileName3 = INPUT_FILE_PATH +
+            "AACLC_44.1kHz_256kbps_s_1_17.mp4";
+        final String[] loggingInfo = new String[2];
+
+        final int videoAspectRatio = MediaProperties.ASPECT_RATIO_3_2;
+        final int videoFileType = MediaProperties.FILE_MP4;
+        final int videoCodecType = MediaProperties.VCODEC_H264BP;
+        final int videoDuration = 77366;
+        final int videoProfile = 0;
+        final int videoHeight = MediaProperties.HEIGHT_720;
+        final int videoWidth = 1080;
+
+        final int imageAspectRatio = MediaProperties.ASPECT_RATIO_4_3;
+        final int imageFileType = MediaProperties.FILE_JPEG;
+        final int imageWidth = 640;
+        final int imageHeight = MediaProperties.HEIGHT_480;
+
+        final int audioDuration = 77554;
+        final int audioCodecType = MediaProperties.ACODEC_AAC_LC;
+        final int audioSamplingFrequency = 44100;
+        final int audioChannel = 2;
+
+        // Take snapShot of Java and Native Memory
+        // System gC
+        System.gc();
+        final Runtime runtimeObjStart = Runtime.getRuntime();
+        final long javaMemStart = runtimeObjStart.totalMemory();
+        final long nativeMemStart = Debug.getNativeHeapAllocatedSize();
+        for (int i = 0; i < 200; i++) {
+            if (i % 3 == 0) {
+                final MediaVideoItem mediaItem1 = new MediaVideoItem(mVideoEditor,
+                    "m1" + i, VideoItemFileName1, renderingMode);
+                mVideoEditor.addMediaItem(mediaItem1);
+                mediaItem1.setExtractBoundaries(0, 20000);
+                assertEquals("Aspect Ratio Mismatch",
+                    videoAspectRatio, mediaItem1.getAspectRatio());
+                assertEquals("File Type Mismatch",
+                    videoFileType, mediaItem1.getFileType());
+                assertEquals("VideoCodec Mismatch",
+                    videoCodecType, mediaItem1.getVideoType());
+                assertEquals("duration Mismatch",
+                    videoDuration, mediaItem1.getDuration());
+                assertEquals("Video Profile ",
+                    videoProfile, mediaItem1.getVideoProfile());
+                assertEquals("Video height ",
+                    videoHeight, mediaItem1.getHeight());
+                assertEquals("Video width ",
+                    videoWidth, mediaItem1.getWidth());
+                mVideoEditor.removeMediaItem("m1" + i);
+            }
+            if (i % 3 == 1) {
+                final MediaImageItem mediaItem2 = new MediaImageItem(mVideoEditor,
+                    "m2" + i, ImageItemFileName2, 10000, renderingMode);
+                mVideoEditor.addMediaItem(mediaItem2);
+                assertEquals("Aspect Ratio Mismatch",
+                    imageAspectRatio, mediaItem2.getAspectRatio());
+                assertEquals("File Type Mismatch",
+                    imageFileType, mediaItem2.getFileType());
+                assertEquals("Image height",
+                    imageHeight, mediaItem2.getHeight());
+                assertEquals("Image width",
+                    imageWidth, mediaItem2.getWidth());
+                mVideoEditor.removeMediaItem("m2" + i);
+            }
+            if (i % 3 == 2) {
+                final AudioTrack mediaItem3 = new AudioTrack(mVideoEditor,
+                    "m3" + i, AudioItemFileName3);
+                mVideoEditor.addAudioTrack(mediaItem3);
+                assertEquals("AudioType Mismatch", audioCodecType,
+                    mediaItem3.getAudioType());
+                assertEquals("Audio Sampling", audioSamplingFrequency,
+                    mediaItem3.getAudioSamplingFrequency());
+                assertEquals("Audio Channels",
+                    audioChannel, mediaItem3.getAudioChannels());
+                assertEquals("duration Mismatch", audioDuration,
+                    mediaItem3.getDuration());
+                mVideoEditor.removeAudioTrack("m3" + i);
+            }
+        }
+        // We will sleep for some time & do an Explicit GC, So that we can get
+        // real memory snapshot
+        System.gc();
+        Thread.sleep(2500);
+        final Runtime runtimeObjEnd = Runtime.getRuntime();
+        final long javaMemEnd = runtimeObjEnd.totalMemory();
+        final long nativeMemEnd = Debug.getNativeHeapAllocatedSize();
+        loggingInfo[0] = "Java Memory at Start = " + javaMemStart +
+            "\t\tJava Memory at End = " + javaMemEnd +
+            "\t\tJava Memory (End - Start) = " + (javaMemEnd - javaMemStart);
+        loggingInfo[1] = "Native Memory at Start = " + nativeMemStart +
+            "\tNative Memory at End = " + nativeMemEnd +
+            "\t\tNative Memory (End - Start) = " + (nativeMemEnd-nativeMemStart);
+        writeTimingInfo("testStressMediaProperties", loggingInfo);
+    }
+
+    /**
+     * To stress test insert and move of mediaitems
+     *
+     * @throws Exception
+     */
+    // TODO : remove TC_STR_008
+    @LargeTest
+    public void testStressInsertMoveItems() throws Exception {
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        final String VideoItemFileName1 = INPUT_FILE_PATH +
+            "H264_BP_1080x720_30fps_800kbps_1_17.mp4";
+        final String VideoItemFileName2 = INPUT_FILE_PATH +
+            "H264_BP_800x480_15fps_512kbps_1_17.mp4";
+        final String VideoItemFileName3 = INPUT_FILE_PATH +
+            "MPEG4_SP_640x480_15fps_1200kbps_AACLC_48khz_64kbps_m_1_17.3gp";
+        final String[] loggingInfo = new String[4];
+
+        // Take snapShot of Java and Native Memory
+        // System gC
+        System.gc();
+        final Runtime runtimeObjStart = Runtime.getRuntime();
+        final long javaMemStart = runtimeObjStart.totalMemory();
+        final long nativeMemStart = Debug.getNativeHeapAllocatedSize();
+
+        final MediaVideoItem mediaItem1 = new MediaVideoItem(mVideoEditor,
+            "m1", VideoItemFileName1, renderingMode);
+        mVideoEditor.addMediaItem(mediaItem1);
+        mediaItem1.setExtractBoundaries(0, 10000);
+
+        final MediaVideoItem mediaItem2 = new MediaVideoItem(mVideoEditor,
+            "m2", VideoItemFileName2, renderingMode);
+        mVideoEditor.addMediaItem(mediaItem2);
+        mediaItem2.setExtractBoundaries(0, 15000);
+
+        for (int i = 0; i < 500; i++) {
+            final MediaVideoItem mediaItem3 = new MediaVideoItem(mVideoEditor,
+                "m3" + i, VideoItemFileName3, renderingMode);
+            mediaItem3.setExtractBoundaries(0, 15000);
+            mVideoEditor.insertMediaItem(mediaItem3, "m1");
+        }
+
+        for (int i = 0; i < 500; i++) {
+            mVideoEditor.moveMediaItem("m2", "m3" + i);
+        }
+        // We will sleep for some time & do an Explicit GC, So that we can get
+        // real memory snapshot
+        System.gc();
+        Thread.sleep(2500);
+        final Runtime runtimeObjEnd = Runtime.getRuntime();
+        final long javaMemEnd = runtimeObjEnd.totalMemory();
+        final long nativeMemEnd = Debug.getNativeHeapAllocatedSize();
+        loggingInfo[0] = "Java Memory at Start = " + javaMemStart +
+            "\t\tJava Memory at End = " + javaMemEnd +
+            "\t\tJava Memory (End - Start) = " + (javaMemEnd - javaMemStart);
+        loggingInfo[1] = "Native Memory at Start = " + nativeMemStart +
+            "\tNative Memory at End = " + nativeMemEnd +
+            "\t\tNative Memory (End-Start)= " + (nativeMemEnd - nativeMemStart);
+
+        /** Remove items and check for memory leak if any */
+        // Take snapShot of Java and Native Memory, do a GC
+        System.gc();
+        final Runtime runtimeObjStart1 = Runtime.getRuntime();
+        final long javaMemStart1 = runtimeObjStart.totalMemory();
+        final long nativeMemStart1 = Debug.getNativeHeapAllocatedSize();
+        for (int i = 0; i < 500; i++) {
+            mVideoEditor.removeMediaItem("m3" + i);
+        }
+            mVideoEditor.removeMediaItem("m2");
+            mVideoEditor.removeMediaItem("m1");
+        // We will sleep for some time & do an Explicit GC, So that we can get
+        // real memory snapshot
+        System.gc();
+        Thread.sleep(2500);
+        final Runtime runtimeObjEnd1 = Runtime.getRuntime();
+        final long javaMemEnd1 = runtimeObjEnd.totalMemory();
+        final long nativeMemEnd1 = Debug.getNativeHeapAllocatedSize();
+        loggingInfo[2] = "\nAfter removal:\nJava Memory at Start = " +
+            javaMemStart1 + "\n\tJava Memory at End = " + javaMemEnd1 +
+            "\n\tJava Memory (End - Start) = " + (javaMemEnd1 - javaMemStart1);
+        loggingInfo[3] = "Native Memory at Start = " + nativeMemStart1 +
+            "\n\tNative Memory at End = " + nativeMemEnd1 +
+            "\n\tNative Memory (End-Start)= " + (nativeMemEnd1-nativeMemStart1);
+
+        writeTimingInfo("testStressInsertMoveItems", loggingInfo);
+    }
+
+    /**
+     * To stress test : load and save
+     *
+     * @throws Exception
+     */
+    // TODO : remove TC_STR_009
+    @LargeTest
+    public void testStressLoadAndSave() throws Exception {
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        final String VideoItemFileName1 = INPUT_FILE_PATH +
+            "H264_BP_1080x720_30fps_800kbps_1_17.mp4";
+        final String VideoItemFileName2 = INPUT_FILE_PATH +
+            "H264_BP_800x480_15fps_512kbps_1_17.mp4";
+        final String VideoItemFileName3 = INPUT_FILE_PATH +
+            "MPEG4_SP_640x480_15fps_1200kbps_AACLC_48khz_64kbps_m_1_17.3gp";
+        final String ImageItemFileName4 = INPUT_FILE_PATH +
+            "IMG_640x480.jpg";
+        final String ImageItemFileName5 = INPUT_FILE_PATH +
+            "IMG_176x144.jpg";
+        final String OverlayFile6 = INPUT_FILE_PATH +
+            "IMG_640x480_Overlay1.png";
+        final String[] loggingInfo = new String[4];
+
+        final String[] projectPath = new String[10];
+
+        // Take snapShot of Java and Native Memory
+        // System gC
+        System.gc();
+        final Runtime runtimeObjStart = Runtime.getRuntime();
+        final long javaMemStart = runtimeObjStart.totalMemory();
+        final long nativeMemStart = Debug.getNativeHeapAllocatedSize();
+
+        for(int i=0; i < 10; i++){
+
+            projectPath[i] =
+                mVideoEditorHelper.createRandomFile(PROJECT_LOCATION);
+            final VideoEditor mVideoEditor1 =
+                mVideoEditorHelper.createVideoEditor(projectPath[i]);
+
+            final MediaVideoItem mediaItem1 = new MediaVideoItem(mVideoEditor1,
+                "m1", VideoItemFileName1, renderingMode);
+            mVideoEditor1.addMediaItem(mediaItem1);
+            mediaItem1.setExtractBoundaries(0, 10000);
+
+            final MediaVideoItem mediaItem2 = new MediaVideoItem(mVideoEditor1,
+                "m2", VideoItemFileName2, renderingMode);
+            mVideoEditor1.addMediaItem(mediaItem2);
+            mediaItem2.setExtractBoundaries(mediaItem2.getDuration()/4,
+                mediaItem2.getDuration()/2);
+
+            final MediaVideoItem mediaItem3 = new MediaVideoItem(mVideoEditor1,
+                "m3", VideoItemFileName3, renderingMode);
+            mVideoEditor1.addMediaItem(mediaItem3);
+            mediaItem3.setExtractBoundaries(mediaItem3.getDuration()/2,
+                mediaItem3.getDuration());
+
+            final MediaImageItem mediaItem4 = new MediaImageItem(mVideoEditor1,
+                "m4", ImageItemFileName4, 5000, renderingMode);
+            mVideoEditor1.addMediaItem(mediaItem4);
+
+            final MediaImageItem mediaItem5 = new MediaImageItem(mVideoEditor1,
+                "m5", ImageItemFileName5, 5000, renderingMode);
+            mVideoEditor1.addMediaItem(mediaItem5);
+
+            final EffectColor effectColor1 =
+                mVideoEditorHelper.createEffectItem(mediaItem3, "effect1",
+                    10000, 2000, EffectColor.TYPE_COLOR, EffectColor.GREEN);
+            mediaItem3.addEffect(effectColor1);
+
+            final Bitmap mBitmap =  mVideoEditorHelper.getBitmap(OverlayFile6,
+                640, 480);
+            final OverlayFrame overlayFrame =
+                mVideoEditorHelper.createOverlay(mediaItem4, "overlay",
+                    mBitmap, 4000, 1000);
+            mediaItem4.addOverlay(overlayFrame);
+
+            final TransitionCrossfade tranCrossfade =
+                new TransitionCrossfade("transCF", mediaItem1,
+                    mediaItem2, 5000, Transition.BEHAVIOR_MIDDLE_FAST);
+            mVideoEditor1.addTransition(tranCrossfade);
+
+            final EffectColor effectColor2 =
+                mVideoEditorHelper.createEffectItem(mediaItem4, "effect2", 0,
+                    mediaItem4.getDuration(), EffectColor.TYPE_COLOR,
+                    EffectColor.PINK);
+            mediaItem4.addEffect(effectColor2);
+
+            mVideoEditor1.generatePreview(new MediaProcessingProgressListener() {
+                public void onProgress(Object item, int action, int progress) {
+                }
+            });
+
+            mVideoEditor1.save();
+            mVideoEditor1.release();
+        }
+        // We will sleep for some time & do an Explicit GC, So that we can get
+        // real memory snapshot
+        System.gc();
+        Thread.sleep(2500);
+        final Runtime runtimeObjEnd = Runtime.getRuntime();
+        final long javaMemEnd = runtimeObjEnd.totalMemory();
+        final long nativeMemEnd = Debug.getNativeHeapAllocatedSize();
+        loggingInfo[0] = "Java Memory at Start = " + javaMemStart +
+            "\n\tJava Memory at End = " + javaMemEnd +
+            "\n\tJava Memory (End - Start) = " + (javaMemEnd - javaMemStart);
+        loggingInfo[1] = "Native Memory at Start = " + nativeMemStart +
+            "\n\tNative Memory at End = " + nativeMemEnd +
+            "\n\tNative Memory (End-Start)= " + (nativeMemEnd - nativeMemStart);
+
+        /** Remove items and check for memory leak if any */
+        // Take snapShot of Java and Native Memory, do a GC
+        System.gc();
+        final Runtime runtimeObjStart1 = Runtime.getRuntime();
+        final long javaMemStart1 = runtimeObjStart.totalMemory();
+        final long nativeMemStart1 = Debug.getNativeHeapAllocatedSize();
+
+        for(int i=0; i<10; i++){
+            final VideoEditor mVideoEditor1b =
+                VideoEditorFactory.load(projectPath[i], true);
+            List<MediaItem> mediaList = mVideoEditor1b.getAllMediaItems();
+            assertEquals("Media Item List Size", 5, mediaList.size());
+
+            mediaList.get(3).removeEffect("effect1");
+            mediaList.get(3).removeEffect("effect2");
+            mediaList.get(2).removeOverlay("overlay");
+            mVideoEditor1b.removeTransition("transCF");
+            mVideoEditor1b.removeMediaItem("m5");
+            mVideoEditor1b.removeMediaItem("m4");
+            mVideoEditor1b.removeMediaItem("m3");
+            mVideoEditor1b.removeMediaItem("m2");
+            mVideoEditor1b.removeMediaItem("m1");
+            mVideoEditor1b.release();
+        }
+        // We will sleep for some time & do an Explicit GC, So that we can get
+        // real memory snapshot
+        System.gc();
+        Thread.sleep(2500);
+        final Runtime runtimeObjEnd1 = Runtime.getRuntime();
+        final long javaMemEnd1 = runtimeObjEnd.totalMemory();
+        final long nativeMemEnd1 = Debug.getNativeHeapAllocatedSize();
+        loggingInfo[2] = "\nAfter removal:\nJava Memory at Start = " +
+            javaMemStart1 + "\n\tJava Memory at End = " + javaMemEnd1 +
+            "\n\tJava Memory (End - Start) = " + (javaMemEnd1 - javaMemStart1);
+        loggingInfo[3] = "Native Memory at Start = " + nativeMemStart1 +
+            "\n\tNative Memory at End = " + nativeMemEnd1 +
+            "\n\tNative Memory (End-Start)= " + (nativeMemEnd1-nativeMemStart1);
+        writeTimingInfo("testStressLoadAndSave", loggingInfo);
+    }
+
+    /**
+     * To stress test : Multiple Export
+     *
+     * @throws Exception
+     */
+    // TODO : remove TC_STR_010
+    @LargeTest
+    public void testStressMultipleExport() throws Exception {
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        final String VideoItemFileName1 = INPUT_FILE_PATH +
+            "H264_BP_1080x720_30fps_800kbps_1_17.mp4";
+        final String VideoItemFileName2 = INPUT_FILE_PATH +
+            "H264_BP_800x480_15fps_512kbps_1_17.mp4";
+        final String VideoItemFileName3 = INPUT_FILE_PATH +
+            "MPEG4_SP_640x480_15fps_1200kbps_AACLC_48khz_64kbps_m_1_17.3gp";
+        final String[] loggingInfo = new String[4];
+
+        final String outFilename = mVideoEditorHelper.createRandomFile(
+            mVideoEditor.getPath() + "/") + ".3gp";
+
+        // Take snapShot of Java and Native Memory
+        // System gC
+        System.gc();
+        final Runtime runtimeObjStart = Runtime.getRuntime();
+        final long javaMemStart = runtimeObjStart.totalMemory();
+        final long nativeMemStart = Debug.getNativeHeapAllocatedSize();
+
+        final MediaVideoItem mediaItem1 = new MediaVideoItem(mVideoEditor,
+            "m1", VideoItemFileName1, renderingMode);
+        mVideoEditor.addMediaItem(mediaItem1);
+        mediaItem1.setExtractBoundaries(0, 10000);
+
+        final MediaVideoItem mediaItem2 = new MediaVideoItem(mVideoEditor,
+            "m2", VideoItemFileName2, renderingMode);
+        mVideoEditor.addMediaItem(mediaItem2);
+        mediaItem2.setExtractBoundaries(0, 15000);
+
+        for (int i = 0; i < 100; i++) {
+            if(i%4 ==0){
+                final int aspectRatio = MediaProperties.ASPECT_RATIO_4_3;
+                mVideoEditor.setAspectRatio(aspectRatio);
+                mVideoEditor.export(outFilename, MediaProperties.HEIGHT_480,
+                    MediaProperties.BITRATE_256K,MediaProperties.ACODEC_AAC_LC,
+                        MediaProperties.VCODEC_H263,
+                        new ExportProgressListener() {
+                        public void onProgress(VideoEditor ve, String outFileName,
+                            int progress) {
+                        }
+                    });
+            }
+            if(i%4 ==1){
+                final int aspectRatio = MediaProperties.ASPECT_RATIO_5_3;
+                mVideoEditor.setAspectRatio(aspectRatio);
+                mVideoEditor.export(outFilename, MediaProperties.HEIGHT_144,
+                    MediaProperties.BITRATE_384K,MediaProperties.ACODEC_AAC_LC,
+                        MediaProperties.VCODEC_MPEG4,
+                        new ExportProgressListener() {
+                        public void onProgress(VideoEditor ve, String outFileName,
+                            int progress) {
+                        }
+                    });
+            }
+            if(i%4 ==2){
+                final int aspectRatio = MediaProperties.ASPECT_RATIO_11_9;
+                mVideoEditor.setAspectRatio(aspectRatio);
+                mVideoEditor.export(outFilename, 640,
+                    MediaProperties.BITRATE_512K,MediaProperties.ACODEC_AAC_LC,
+                        MediaProperties.VCODEC_H264BP,
+                        new ExportProgressListener() {
+                        public void onProgress(VideoEditor ve, String outFileName,
+                            int progress) {
+                        }
+                    });
+            }
+            if(i%4 ==3){
+                final int aspectRatio = MediaProperties.ASPECT_RATIO_3_2;
+                mVideoEditor.setAspectRatio(aspectRatio);
+                mVideoEditor.export(outFilename, MediaProperties.HEIGHT_480,
+                    MediaProperties.BITRATE_800K,MediaProperties.ACODEC_AAC_LC,
+                        MediaProperties.VCODEC_H264BP,
+                        new ExportProgressListener() {
+                        public void onProgress(VideoEditor ve, String outFileName,
+                            int progress) {
+                        }
+                    });
+            }
+        }
+        // We will sleep for some time & do an Explicit GC, So that we can get
+        // real memory snapshot
+        System.gc();
+        Thread.sleep(2500);
+        final Runtime runtimeObjEnd = Runtime.getRuntime();
+        final long javaMemEnd = runtimeObjEnd.totalMemory();
+        final long nativeMemEnd = Debug.getNativeHeapAllocatedSize();
+        loggingInfo[0] = "Java Memory at Start = " + javaMemStart +
+            "\n\tJava Memory at End = " + javaMemEnd +
+            "\n\tJava Memory (End - Start) = " + (javaMemEnd - javaMemStart);
+        loggingInfo[1] = "Native Memory at Start = " + nativeMemStart +
+            "\n\tNative Memory at End = " + nativeMemEnd +
+            "\n\tNative Memory (End-Start)= " + (nativeMemEnd - nativeMemStart);
+
+        /** Remove items and check for memory leak if any */
+        // Take snapShot of Java and Native Memory, do a GC
+        System.gc();
+        final Runtime runtimeObjStart1 = Runtime.getRuntime();
+        final long javaMemStart1 = runtimeObjStart.totalMemory();
+        final long nativeMemStart1 = Debug.getNativeHeapAllocatedSize();
+
+        mVideoEditor.removeMediaItem("m2");
+        mVideoEditor.removeMediaItem("m1");
+
+        // We will sleep for some time & do an Explicit GC, So that we can get
+        // real memory snapshot
+        System.gc();
+        Thread.sleep(2500);
+        final Runtime runtimeObjEnd1 = Runtime.getRuntime();
+        final long javaMemEnd1 = runtimeObjEnd.totalMemory();
+        final long nativeMemEnd1 = Debug.getNativeHeapAllocatedSize();
+        loggingInfo[2] = "\nAfter removal:\nJava Memory at Start = " +
+            javaMemStart1 + "\n\tJava Memory at End = " + javaMemEnd1 +
+            "\n\tJava Memory (End - Start) = " + (javaMemEnd1 - javaMemStart1);
+        loggingInfo[3] = "Native Memory at Start = " + nativeMemStart1 +
+            "\n\tNative Memory at End = " + nativeMemEnd1 +
+            "\n\tNative Memory (End-Start)= " + (nativeMemEnd1-nativeMemStart1);
+        writeTimingInfo("testStressMultipleExport", loggingInfo);
+    }
+
+
+    /**
+     * To stress test Media Item,Overlays,Transitions and Ken Burn
+     *
+     * @throws Exception
+     */
+    // TODO : remove TC_STR_011
+    @LargeTest
+    public void testStressOverlayTransKenBurn() throws Exception {
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        final String VideoItemFileName1 = INPUT_FILE_PATH +
+            "H264_BP_640x480_30fps_256kbps_1_17.mp4";
+        final String ImageItemFileName2 = INPUT_FILE_PATH +
+            "IMG_640x480.jpg";
+        final String OverlayFile3 = INPUT_FILE_PATH +
+            "IMG_640x480_Overlay1.png";
+        final String audioFilename4 = INPUT_FILE_PATH +
+            "AACLC_44.1kHz_256kbps_s_1_17.mp4";
+
+        final String[] loggingInfo = new String[4];
+
+        // Take snapShot of Java and Native Memory, do a GC
+        System.gc();
+        final Runtime runtimeObjStart = Runtime.getRuntime();
+        final long javaMemStart = runtimeObjStart.totalMemory();
+        final long nativeMemStart = Debug.getNativeHeapAllocatedSize();
+        for (int i = 0; i < 10; i++) {
+            final MediaVideoItem mediaItem1 = new MediaVideoItem(mVideoEditor,
+                "m1" + i, VideoItemFileName1, renderingMode);
+            mVideoEditor.addMediaItem(mediaItem1);
+            mediaItem1.setExtractBoundaries(0, 10000);
+
+            final MediaImageItem mediaItem2 = new MediaImageItem(mVideoEditor,
+                "m2" + i, ImageItemFileName2, 10000, renderingMode);
+            mVideoEditor.addMediaItem(mediaItem2);
+
+            final EffectColor effectColor1 =
+                mVideoEditorHelper.createEffectItem(mediaItem1, "effect1"+i,
+                    (mediaItem1.getDuration() - 4000), 4000,
+                    EffectColor.TYPE_SEPIA, 0);
+            mediaItem1.addEffect(effectColor1);
+
+            final TransitionCrossfade tranCrossfade =
+                new TransitionCrossfade("transCF" + i, mediaItem1,
+                    mediaItem2, 4000, Transition.BEHAVIOR_MIDDLE_FAST);
+            mVideoEditor.addTransition(tranCrossfade);
+
+            final Bitmap mBitmap =  mVideoEditorHelper.getBitmap(OverlayFile3,
+                640, 480);
+            final OverlayFrame overlayFrame =
+                mVideoEditorHelper.createOverlay(mediaItem1, "overlay" + i,
+                    mBitmap, 1000, 5000);
+            mediaItem1.addOverlay(overlayFrame);
+
+            final Rect startRect = new Rect((mediaItem2.getHeight() / 3),
+                (mediaItem2.getWidth() / 3), (mediaItem2.getHeight() / 2),
+                (mediaItem2.getWidth() / 2));
+            final Rect endRect = new Rect(0, 0, mediaItem2.getWidth(),
+                mediaItem2.getHeight());
+
+            final EffectKenBurns kbEffectOnMediaItem = new EffectKenBurns(
+                mediaItem2, "KBOnM2" + i, startRect, endRect, 500,
+                (mediaItem2.getDuration()-500));
+            mediaItem2.addEffect(kbEffectOnMediaItem);
+
+            if(i == 5) {
+                final AudioTrack audioTrack1 = new AudioTrack(mVideoEditor,
+                    "Audio Track1", audioFilename4);
+                mVideoEditor.addAudioTrack(audioTrack1);
+            }
+
+        }
+        // We will sleep for some time & do an Explicit GC, So that we can get
+        // real memory snapshot
+        System.gc();
+        Thread.sleep(2500);
+        final Runtime runtimeObjEnd = Runtime.getRuntime();
+        final long javaMemEnd = runtimeObjEnd.totalMemory();
+        final long nativeMemEnd = Debug.getNativeHeapAllocatedSize();
+        loggingInfo[0] = "Java Memory at Start = " + javaMemStart +
+            "\n\tJava Memory at End = " + javaMemEnd +
+            "\n\tJava Memory (End - Start) = " + (javaMemEnd - javaMemStart);
+        loggingInfo[1] = "Native Memory at Start = " + nativeMemStart +
+            "\n\tNative Memory at End = " + nativeMemEnd +
+            "\n\tNative Memory (End-Start)= " + (nativeMemEnd - nativeMemStart);
+
+        /** Remove items and check for memory leak if any */
+        // Take snapShot of Java and Native Memory, do a GC
+        System.gc();
+        final Runtime runtimeObjStart1 = Runtime.getRuntime();
+        final long javaMemStart1 = runtimeObjStart.totalMemory();
+        final long nativeMemStart1 = Debug.getNativeHeapAllocatedSize();
+
+        for (int i = 0; i < 10; i++) {
+            MediaImageItem m2 = (MediaImageItem)mVideoEditor.getMediaItem("m2"+i);
+            MediaVideoItem m1 = (MediaVideoItem)mVideoEditor.getMediaItem("m1"+i);
+            m2.removeEffect("KBOnM2" + i);
+            m1.removeOverlay("overlay" + i);
+            mVideoEditor.removeTransition("transCF" + i);
+            m1.removeEffect("effect1" + i);
+            mVideoEditor.removeMediaItem("m2" + i);
+            mVideoEditor.removeMediaItem("m1" + i);
+            if(i == 5) {
+                mVideoEditor.removeAudioTrack("Audio Track1");
+            }
+        }
+        // We will sleep for some time & do an Explicit GC, So that we can get
+        // real memory snapshot
+        System.gc();
+        Thread.sleep(2500);
+        final Runtime runtimeObjEnd1 = Runtime.getRuntime();
+        final long javaMemEnd1 = runtimeObjEnd.totalMemory();
+        final long nativeMemEnd1 = Debug.getNativeHeapAllocatedSize();
+        loggingInfo[2] = "\nAfter removal:\nJava Memory at Start = " +
+            javaMemStart1 + "\n\tJava Memory at End = " + javaMemEnd1 +
+            "\n\tJava Memory (End - Start) = " + (javaMemEnd1 - javaMemStart1);
+        loggingInfo[3] = "Native Memory at Start = " + nativeMemStart1 +
+            "\n\tNative Memory at End = " + nativeMemEnd1 +
+            "\n\tNative Memory (End-Start)= " + (nativeMemEnd1-nativeMemStart1);
+        writeTimingInfo("testStressOverlayTransKenBurn", loggingInfo);
+    }
+
+    /**
+     * To test the performance : With an audio track with Video
+     *
+     * @throws Exception
+     */
+    // TODO : remove TC_STR_012
+    @LargeTest
+    public void testStressAudioTrackVideo() throws Exception {
+        final String videoItemFileName1 = INPUT_FILE_PATH +
+            "H264_BP_1080x720_30fps_800kbps_1_17.mp4";
+        final String audioFilename1 = INPUT_FILE_PATH +
+            "AACLC_44.1kHz_256kbps_s_1_17.mp4";
+        final String audioFilename2 = INPUT_FILE_PATH +
+            "AMRNB_8KHz_12.2Kbps_m_1_17.3gp";
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        final int audioVolume = 50;
+        final String[] loggingInfo = new String[4];
+
+        // Take snapShot of Java and Native Memory
+        // System gC
+        System.gc();
+        final Runtime runtimeObjStart = Runtime.getRuntime();
+        final long javaMemStart = runtimeObjStart.totalMemory();
+        final long nativeMemStart = Debug.getNativeHeapAllocatedSize();
+
+        final MediaVideoItem mediaVideoItem = new MediaVideoItem(mVideoEditor,
+            "mediaItem1", videoItemFileName1, renderingMode);
+        mVideoEditor.addMediaItem(mediaVideoItem);
+
+        final AudioTrack audioTrack1 = new AudioTrack(mVideoEditor,
+            "Audio Track1", audioFilename1);
+        audioTrack1.disableDucking();
+        audioTrack1.setVolume(audioVolume);
+        mVideoEditor.addAudioTrack(audioTrack1);
+
+        mVideoEditor.generatePreview(new MediaProcessingProgressListener() {
+            public void onProgress(Object item, int action, int progress) {
+            }
+        });
+
+        mVideoEditor.removeAudioTrack("Audio Track1");
+
+        final AudioTrack audioTrack2 = new AudioTrack(mVideoEditor,
+            "Audio Track2", audioFilename2);
+        audioTrack2.enableLoop();
+
+        mVideoEditor.generatePreview(new MediaProcessingProgressListener() {
+            public void onProgress(Object item, int action, int progress) {
+            }
+        });
+
+        // We will sleep for some time & do an Explicit GC, So that we can get
+        // real memory snapshot
+        System.gc();
+        Thread.sleep(2500);
+        final Runtime runtimeObjEnd = Runtime.getRuntime();
+        final long javaMemEnd = runtimeObjEnd.totalMemory();
+        final long nativeMemEnd = Debug.getNativeHeapAllocatedSize();
+        loggingInfo[0] = "Java Memory at Start = " + javaMemStart +
+            "\t\tJava Memory at End = " + javaMemEnd +
+            "\t\tJava Memory (End - Start) = " + (javaMemEnd - javaMemStart);
+        loggingInfo[1] = "Native Memory at Start = " + nativeMemStart +
+            "\tNative Memory at End = " + nativeMemEnd +
+            "\t\tNative Memory (End-Start) = " + (nativeMemEnd - nativeMemStart);
+
+        /** Remove items and check for memory leak if any */
+        // Take snapShot of Java and Native Memory, do a GC
+        System.gc();
+        final Runtime runtimeObjStart1 = Runtime.getRuntime();
+        final long javaMemStart1 = runtimeObjStart.totalMemory();
+        final long nativeMemStart1 = Debug.getNativeHeapAllocatedSize();
+
+        mVideoEditor.removeMediaItem("mediaItem1");
+
+        // We will sleep for some time & do an Explicit GC, So that we can get
+        // real memory snapshot
+        System.gc();
+        Thread.sleep(2500);
+        final Runtime runtimeObjEnd1 = Runtime.getRuntime();
+        final long javaMemEnd1 = runtimeObjEnd.totalMemory();
+        final long nativeMemEnd1 = Debug.getNativeHeapAllocatedSize();
+        loggingInfo[2] = "\nAfter removal:\nJava Memory at Start = " +
+            javaMemStart1 + "\n\tJava Memory at End = " + javaMemEnd1 +
+            "\n\tJava Memory (End - Start) = " + (javaMemEnd1 - javaMemStart1);
+        loggingInfo[3] = "Native Memory at Start = " + nativeMemStart1 +
+            "\n\tNative Memory at End = " + nativeMemEnd1 +
+            "\n\tNative Memory (End-Start)= " + (nativeMemEnd1-nativeMemStart1);
+
+        writeTimingInfo("testStressAudioTrackVideo", loggingInfo);
+    }
+
+    /**
+     * To Test Stress : Story Board creation with out preview or export
+     *
+     * @throws Exception
+     */
+    // TODO : remove TC_STR_013
+    @LargeTest
+    public void testStressStoryBoard() throws Exception {
+        final String videoItemFileName1 = INPUT_FILE_PATH +
+            "MPEG4_SP_720x480_30fps_280kbps_AACLC_48kHz_161kbps_s_0_26.mp4";
+        final String videoItemFileName2 = INPUT_FILE_PATH +
+            "MPEG4_SP_854x480_15fps_256kbps_AACLC_16khz_48kbps_s_0_26.mp4";
+        final String videoItemFileName3= INPUT_FILE_PATH +
+            "MPEG4_SP_640x480_15fps_512kbps_AACLC_48khz_132kbps_s_0_26.mp4";
+        final String imageItemFileName4 = INPUT_FILE_PATH +
+            "IMG_1600x1200.jpg";
+        final String imageItemFileName5 = INPUT_FILE_PATH +
+            "IMG_176x144.jpg";
+        final String audioFilename6 = INPUT_FILE_PATH +
+            "AMRNB_8KHz_12.2Kbps_m_1_17.3gp";
+        final String audioFilename7 = INPUT_FILE_PATH +
+            "AACLC_44.1kHz_256kbps_s_1_17.mp4";
+
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        final int audioVolume = 50;
+        final String[] loggingInfo = new String[4];
+
+        // Take snapShot of Java and Native Memory
+        // System gC
+        System.gc();
+        final Runtime runtimeObjStart = Runtime.getRuntime();
+        final long javaMemStart = runtimeObjStart.totalMemory();
+        final long nativeMemStart = Debug.getNativeHeapAllocatedSize();
+
+        final MediaVideoItem mediaItem1 = new MediaVideoItem(mVideoEditor,
+            "m1", videoItemFileName1, renderingMode);
+        mediaItem1.setExtractBoundaries(0, 10000);
+        mVideoEditor.addMediaItem(mediaItem1);
+
+        final MediaVideoItem mediaItem2 = new MediaVideoItem(mVideoEditor,
+            "m2", videoItemFileName2, renderingMode);
+        mediaItem2.setExtractBoundaries(mediaItem2.getDuration()/4,
+            mediaItem2.getDuration()/2);
+        mVideoEditor.addMediaItem(mediaItem2);
+
+        final MediaVideoItem mediaItem3 = new MediaVideoItem(mVideoEditor,
+            "m3", videoItemFileName3, renderingMode);
+        mediaItem3.setExtractBoundaries(mediaItem3.getDuration()/2,
+            mediaItem3.getDuration());
+        mVideoEditor.addMediaItem(mediaItem3);
+
+        final MediaImageItem mediaItem4 = new MediaImageItem(mVideoEditor,
+            "m4", imageItemFileName4, 5000, renderingMode);
+        mVideoEditor.addMediaItem(mediaItem4);
+
+        final MediaImageItem mediaItem5 = new MediaImageItem(mVideoEditor,
+            "m5", imageItemFileName5, 5000, renderingMode);
+        mVideoEditor.addMediaItem(mediaItem5);
+
+        final TransitionCrossfade tranCrossfade =
+            new TransitionCrossfade("transCF", mediaItem2, mediaItem3, 2500,
+                Transition.BEHAVIOR_MIDDLE_FAST);
+        mVideoEditor.addTransition(tranCrossfade);
+
+        final TransitionCrossfade tranCrossfade1 =
+            new TransitionCrossfade("transCF1", mediaItem3, mediaItem4, 2500,
+                Transition.BEHAVIOR_MIDDLE_FAST);
+        mVideoEditor.addTransition(tranCrossfade1);
+
+        final AudioTrack audioTrack1 = new AudioTrack(mVideoEditor,
+            "Audio Track1", audioFilename6);
+        mVideoEditor.addAudioTrack(audioTrack1);
+
+        mVideoEditor.removeAudioTrack("Audio Track1");
+        final AudioTrack audioTrack2 = new AudioTrack(mVideoEditor,
+            "Audio Track2", audioFilename7);
+        mVideoEditor.addAudioTrack(audioTrack2);
+        audioTrack2.enableLoop();
+
+        // We will sleep for some time & do an Explicit GC, So that we can get
+        // real memory snapshot
+        System.gc();
+        Thread.sleep(2500);
+        final Runtime runtimeObjEnd = Runtime.getRuntime();
+        final long javaMemEnd = runtimeObjEnd.totalMemory();
+        final long nativeMemEnd = Debug.getNativeHeapAllocatedSize();
+        loggingInfo[0] = "Java Memory at Start = " + javaMemStart +
+            "\t\tJava Memory at End = " + javaMemEnd +
+            "\t\tJava Memory (End - Start) = " + (javaMemEnd - javaMemStart);
+        loggingInfo[1] = "Native Memory at Start = " + nativeMemStart +
+            "\tNative Memory at End = " + nativeMemEnd +
+            "\t\tNative Memory (End-Start) = " + (nativeMemEnd - nativeMemStart);
+
+
+        /** Remove items and check for memory leak if any */
+        // Take snapShot of Java and Native Memory, do a GC
+        System.gc();
+        final Runtime runtimeObjStart1 = Runtime.getRuntime();
+        final long javaMemStart1 = runtimeObjStart.totalMemory();
+        final long nativeMemStart1 = Debug.getNativeHeapAllocatedSize();
+
+        mVideoEditor.removeAudioTrack("Audio Track2");
+        mVideoEditor.removeTransition("transCF");
+        mVideoEditor.removeTransition("transCF1");
+        mVideoEditor.removeMediaItem("m5");
+        mVideoEditor.removeMediaItem("m4");
+        mVideoEditor.removeMediaItem("m3");
+        mVideoEditor.removeMediaItem("m2");
+        mVideoEditor.removeMediaItem("m1");
+
+        // We will sleep for some time & do an Explicit GC, So that we can get
+        // real memory snapshot
+        System.gc();
+        Thread.sleep(2500);
+        final Runtime runtimeObjEnd1 = Runtime.getRuntime();
+        final long javaMemEnd1 = runtimeObjEnd.totalMemory();
+        final long nativeMemEnd1 = Debug.getNativeHeapAllocatedSize();
+        loggingInfo[2] = "\nAfter removal:\nJava Memory at Start = " +
+            javaMemStart1 + "\n\tJava Memory at End = " + javaMemEnd1 +
+            "\n\tJava Memory (End - Start) = " + (javaMemEnd1 - javaMemStart1);
+        loggingInfo[3] = "Native Memory at Start = " + nativeMemStart1 +
+            "\n\tNative Memory at End = " + nativeMemEnd1 +
+            "\n\tNative Memory (End-Start)= " + (nativeMemEnd1-nativeMemStart1);
+
+        writeTimingInfo("testStressStoryBoard", loggingInfo);
+
+    }
+
+     /**
+     * To test the performance : With an audio track Only
+     *
+     * @throws Exception
+     */
+    // TODO : remove TC_STR_014
+    @LargeTest
+    public void testStressAudioTrackOnly() throws Exception {
+
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        final String AudioItemFileName1 = INPUT_FILE_PATH +
+            "AACLC_44.1kHz_256kbps_s_1_17.mp4";
+        final String[] loggingInfo = new String[2];
+        // Take snapShot of Java and Native Memory
+        // System gC
+        System.gc();
+        final Runtime runtimeObjStart = Runtime.getRuntime();
+        final long javaMemStart = runtimeObjStart.totalMemory();
+        final long nativeMemStart = Debug.getNativeHeapAllocatedSize();
+
+        for (int i = 0; i < 200; i++) {
+            final AudioTrack mediaItem1 = new AudioTrack(mVideoEditor,
+                "m1" + i, AudioItemFileName1);
+            mVideoEditor.addAudioTrack(mediaItem1);
+            mediaItem1.enableLoop();
+            mVideoEditor.removeAudioTrack("m1" + i);
+        }
+        // We will sleep for some time & do an Explicit GC, So that we can get
+        // real memory snapshot
+        System.gc();
+        Thread.sleep(2500);
+        final Runtime runtimeObjEnd = Runtime.getRuntime();
+        final long javaMemEnd = runtimeObjEnd.totalMemory();
+        final long nativeMemEnd = Debug.getNativeHeapAllocatedSize();
+        loggingInfo[0] = "Java Memory at Start = " + javaMemStart +
+            "\t\tJava Memory at End = " + javaMemEnd +
+            "\t\tJava Memory (End - Start) = " + (javaMemEnd - javaMemStart);
+        loggingInfo[1] = "Native Memory at Start = " + nativeMemStart +
+            "\tNative Memory at End = " + nativeMemEnd +
+            "\t\tNative Memory (End-Start) = " + (nativeMemEnd - nativeMemStart);
+        writeTimingInfo("testStressAudioTrackOnly", loggingInfo);
+    }
+
+    /**
+     * This method will test thumbnail list extraction in a loop = 200 for Image
+     * Item
+     *
+     * @throws Exception
+     */
+    // TODO : remove TC_STR_016  -- New Test Case
+    @LargeTest
+    public void testStressThumbnailImageItem() throws Exception {
+        final String imageItemFileName = INPUT_FILE_PATH + "IMG_640x480.jpg";
+        final int renderingMode = MediaItem.RENDERING_MODE_BLACK_BORDER;
+        final String[] loggingInfo = new String[2];
+
+        final MediaImageItem mediaImageItem = new MediaImageItem(mVideoEditor,
+            "m1", imageItemFileName, 5000, renderingMode);
+        // Take snapShot of Java and Native Memory
+        // System gC
+        System.gc();
+        final Runtime runtimeObjStart = Runtime.getRuntime();
+        final long javaMemStart = runtimeObjStart.totalMemory();
+        final long nativeMemStart = Debug.getNativeHeapAllocatedSize();
+        for (int i = 0; i < 200; i++) {
+            if (i % 4 == 0) {
+                final Bitmap[] thumbNails = mediaImageItem.getThumbnailList(
+                    mediaImageItem.getWidth() / 2 ,
+                    mediaImageItem.getHeight() / 2, i, 5000, 2);
+                // Recycle this Bitmap array
+                for (int i1 = 0; i1 < thumbNails.length; i1++) {
+                    thumbNails[i1].recycle();
+                }
+            }
+            if (i % 4 == 1) {
+                final Bitmap[] thumbNails = mediaImageItem.getThumbnailList(
+                    mediaImageItem.getWidth() / 2,
+                    mediaImageItem.getHeight() * 3, i, 5000, 2);
+                // Recycle this Bitmap array
+                for (int i1 = 0; i1 < thumbNails.length; i1++) {
+                    thumbNails[i1].recycle();
+                }
+            }
+            if (i % 4 == 2) {
+                final Bitmap[] thumbNails = mediaImageItem.getThumbnailList(
+                    mediaImageItem.getWidth() * 2,
+                    mediaImageItem.getHeight() / 3, i, 5000, 2);
+                // Recycle this Bitmap array
+                for (int i1 = 0; i1 < thumbNails.length; i1++) {
+                    thumbNails[i1].recycle();
+                }
+            }
+            if (i % 4 == 3) {
+                final Bitmap[] thumbNails = mediaImageItem.getThumbnailList(
+                    mediaImageItem.getWidth(),
+                    mediaImageItem.getHeight(), i, 5000, 2);
+                // Recycle this Bitmap array
+                for (int i1 = 0; i1 < thumbNails.length; i1++) {
+                    thumbNails[i1].recycle();
+                }
+            }
+        }
+        // We will sleep for some time & do an Explicit GC, So that we can get
+        // real memory snapshot
+        System.gc();
+        Thread.sleep(2500);
+        final Runtime runtimeObjEnd = Runtime.getRuntime();
+        final long javaMemEnd = runtimeObjEnd.totalMemory();
+        final long nativeMemEnd = Debug.getNativeHeapAllocatedSize();
+        loggingInfo[0] = "Java Memory at Start = " + javaMemStart +
+            "\t\tJava Memory at End = " + javaMemEnd +
+            "\t\tJava Memory (End - Start) = " + (javaMemEnd - javaMemStart);
+        loggingInfo[1] = "Native Memory at Start = " + nativeMemStart +
+            "\tNative Memory at End = " + nativeMemEnd +
+            "\t\tNative Memory (End-Start) = " + (nativeMemEnd - nativeMemStart);
+        writeTimingInfo("testStressThumbnailImageItem", loggingInfo);
+    }
+
+
+
+}