tests/framework/base/windowmanager/src/android/server/wm/intent/Cases.java - platform/cts - Git at Google

 /*
  * Copyright (C) 2019 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 android.server.wm.intent;

 import static android.content.Intent.FLAG_ACTIVITY_CLEAR_TASK;
 import static android.content.Intent.FLAG_ACTIVITY_CLEAR_TOP;
 import static android.content.Intent.FLAG_ACTIVITY_MULTIPLE_TASK;
 import static android.content.Intent.FLAG_ACTIVITY_NEW_DOCUMENT;
 import static android.content.Intent.FLAG_ACTIVITY_NEW_TASK;
 import static android.content.Intent.FLAG_ACTIVITY_NO_HISTORY;
 import static android.content.Intent.FLAG_ACTIVITY_PREVIOUS_IS_TOP;
 import static android.content.Intent.FLAG_ACTIVITY_REORDER_TO_FRONT;
 import static android.content.Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED;
 import static android.content.Intent.FLAG_ACTIVITY_SINGLE_TOP;
 import static android.server.wm.intent.LaunchSequence.intent;
 import static android.server.wm.intent.LaunchSequence.intentForResult;
 import static android.server.wm.intent.Persistence.flag;

 import android.content.Intent;
 import android.server.wm.intent.Activities.RegularActivity;
 import android.server.wm.intent.Persistence.IntentFlag;
 import android.server.wm.intent.Persistence.LaunchIntent;

 import com.google.common.collect.Lists;

 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;

 /**
  * Contains all information to create and reuse intent test launches.
  * It enumerates all the flags so they can easily be used.
  *
  * It also stores commonly used {@link LaunchSequence} objects for reuse.
  */
 public class Cases {

     public static final IntentFlag CLEAR_TASK = flag(FLAG_ACTIVITY_CLEAR_TASK,
             "FLAG_ACTIVITY_CLEAR_TASK");
     public static final IntentFlag CLEAR_TOP = flag(FLAG_ACTIVITY_CLEAR_TOP,
             "FLAG_ACTIVITY_CLEAR_TOP");
     private static final IntentFlag SINGLE_TOP = flag(FLAG_ACTIVITY_SINGLE_TOP,
             "FLAG_ACTIVITY_SINGLE_TOP");
     public static final IntentFlag NEW_TASK = flag(FLAG_ACTIVITY_NEW_TASK,
             "FLAG_ACTIVITY_NEW_TASK");
     public static final IntentFlag NEW_DOCUMENT = flag(FLAG_ACTIVITY_NEW_DOCUMENT,
             "FLAG_ACTIVITY_NEW_DOCUMENT");
     private static final IntentFlag MULTIPLE_TASK = flag(FLAG_ACTIVITY_MULTIPLE_TASK,
             "FLAG_ACTIVITY_MULTIPLE_TASK");
     public static final IntentFlag RESET_TASK_IF_NEEDED = flag(
             FLAG_ACTIVITY_RESET_TASK_IF_NEEDED,
             "FLAG_ACTIVITY_RESET_TASK_IF_NEEDED");
     public static final IntentFlag PREVIOUS_IS_TOP = flag(FLAG_ACTIVITY_PREVIOUS_IS_TOP,
             "FLAG_ACTIVITY_PREVIOUS_IS_TOP");
     public static final IntentFlag REORDER_TO_FRONT = flag(FLAG_ACTIVITY_REORDER_TO_FRONT,
             "FLAG_ACTIVITY_REORDER_TO_FRONT");
     public static final IntentFlag NO_HISTORY = flag(FLAG_ACTIVITY_NO_HISTORY,
             "FLAG_ACTIVITY_NO_HISTORY");

     // Flag only used for parsing intents that contain no flags.
     private static final IntentFlag NONE = flag(0, "");

     public final List<IntentFlag> flags = Lists.newArrayList(
             CLEAR_TASK,
             CLEAR_TOP,
             SINGLE_TOP,
             NEW_TASK,
             NEW_DOCUMENT,
             MULTIPLE_TASK,
             RESET_TASK_IF_NEEDED,
             PREVIOUS_IS_TOP,
             REORDER_TO_FRONT,
             NO_HISTORY
     );

     // Definition of intents used across multiple test cases.
     private final LaunchIntent mRegularIntent = intent(RegularActivity.class);
     private final LaunchIntent mSingleTopIntent = intent(Activities.SingleTopActivity.class);
     private final LaunchIntent mAff1Intent = intent(Activities.TaskAffinity1Activity.class);
     private final LaunchIntent mSecondAff1Intent = intent(Activities.TaskAffinity1Activity2.class);
     private final LaunchIntent mSingleInstanceIntent = intent(
             Activities.SingleInstanceActivity.class);
     private final LaunchIntent mSingleTaskIntent = intent(Activities.SingleTaskActivity.class);
     private final LaunchIntent mRegularForResultIntent = intentForResult(RegularActivity.class);

     // LaunchSequences used across multiple test cases.
     private final LaunchSequence mRegularSequence = LaunchSequence.create(mRegularIntent);

     // To show that the most recent task get's resumed by new task
     private final LaunchSequence mTwoAffinitiesSequence =
             LaunchSequence.create(mAff1Intent)
                     .append(mRegularIntent)
                     .append(mAff1Intent.withFlags(NEW_TASK, MULTIPLE_TASK));

     // Used to show that the task affinity is determined by the activity that started it,
     // Not the affinity of the  current root activity.
     private final LaunchSequence mRearrangedRootSequence = LaunchSequence.create(mRegularIntent)
             .append(mAff1Intent.withFlags(NEW_TASK))
             .append(mRegularIntent)
             .append(mAff1Intent.withFlags(REORDER_TO_FRONT));


     private final LaunchSequence mSingleInstanceActivitySequence =
             LaunchSequence.create(mSingleInstanceIntent);

     private final LaunchSequence mSingleTaskActivitySequence = LaunchSequence.create(
             mSingleTaskIntent);

     public List<LaunchSequence> newTaskCases() {
         LaunchIntent aff1NewTask = mAff1Intent.withFlags(NEW_TASK);

         return Lists.newArrayList(
                 // 1. Single instance will start a new task even without new task set
                 mRegularSequence.act(mSingleInstanceIntent),
                 // 2. With new task it will still end up in a new task
                 mRegularSequence.act(mSingleInstanceIntent.withFlags(NEW_TASK)),
                 // 3. Starting an activity with a different affinity without new task will put it in
                 // the existing task
                 mRegularSequence.act(mAff1Intent),
                 // 4. Starting a task with a different affinity and new task will start a new task
                 mRegularSequence.act(aff1NewTask),
                 // 5. Starting the intent with new task will not add a new activity to the task
                 mRegularSequence.act(mRegularIntent.withFlags(NEW_TASK)),
                 // 6. A different activity with the same affinity will start a new activity in
                 // the sam task
                 mRegularSequence.act(mSingleTopIntent.withFlags(NEW_TASK)),
                 // 7. To show that the most recent task get's resumed by new task, this can't
                 // be observed without differences in the same activity / task
                 mTwoAffinitiesSequence.act(aff1NewTask),
                 // 8. To show that new task respects the root as a single even
                 // if it is not at the bottom
                 mRearrangedRootSequence.act(mAff1Intent.withFlags(NEW_TASK)),
                 // 9. To show that new task with non root does start a new activity.
                 mRearrangedRootSequence.act(mSecondAff1Intent.withFlags(NEW_TASK)),
                 // 10. Multiple task will allow starting activities of the same affinity in
                 // different tasks
                 mRegularSequence.act(mRegularIntent.withFlags(NEW_TASK, MULTIPLE_TASK)),
                 // 11. Single instance will not start a new task even with multiple task on
                 mSingleInstanceActivitySequence.act(
                         mSingleInstanceIntent.withFlags(NEW_TASK, MULTIPLE_TASK)),
                 // 12. The same should happen for single task.
                 mSingleTaskActivitySequence.act(
                         mSingleTaskIntent.withFlags(NEW_TASK, MULTIPLE_TASK)),
                 // 13. This starts a regular in a new task
                 mSingleInstanceActivitySequence.act(mRegularIntent),
                 // 14. This adds regular in the same task
                 mSingleTaskActivitySequence.act(mRegularIntent),
                 // 15. Starting the activity for result keeps it in the same task
                 mSingleInstanceActivitySequence.act(mRegularForResultIntent),
                 // 16. Restarts the previous task with regular activity.
                 mRegularSequence.append(mSingleInstanceIntent).act(mRegularIntent)
         );
     }

     /**
      * {@link android.content.Intent#FLAG_ACTIVITY_NEW_DOCUMENT }test cases are the same as
      * {@link Cases#newTaskCases()}, we should check them for differences.
      */
     public List<LaunchSequence> newDocumentCases() {
         LaunchIntent aff1NewDocument = mAff1Intent.withFlags(NEW_DOCUMENT);

         return Lists.newArrayList(
                 // 1. Single instance will start a new task even without new task set
                 mRegularSequence.act(mSingleInstanceIntent),
                 // 2. With new task it will still end up in a new task
                 mRegularSequence.act(mSingleInstanceIntent.withFlags(NEW_DOCUMENT)),
                 // 3. Starting an activity with a different affinity without new task will put it
                 // in the existing task
                 mRegularSequence.act(mAff1Intent),
                 // 4. With new document it will start it's own task
                 mRegularSequence.act(aff1NewDocument),
                 // 5. Starting the intent with new task will not add a new activity to the task
                 mRegularSequence.act(mRegularIntent.withFlags(NEW_DOCUMENT)),
                 // 6. Unlike the case with NEW_TASK, with new Document
                 mRegularSequence.act(mSingleTopIntent.withFlags(NEW_DOCUMENT)),
                 // 7. To show that the most recent task get's resumed by new task
                 mTwoAffinitiesSequence.act(aff1NewDocument),
                 // 8. To show that new task respects the root as a single
                 mRearrangedRootSequence.act(mAff1Intent.withFlags(NEW_DOCUMENT)),
                 // 9. New document starts a third task here, because there was no task for the
                 // document yet
                 mRearrangedRootSequence.act(mSecondAff1Intent.withFlags(NEW_DOCUMENT)),
                 // 10. Multiple task wil allow starting activities of the same affinity in different
                 // tasks
                 mRegularSequence.act(mRegularIntent.withFlags(NEW_DOCUMENT, MULTIPLE_TASK)),
                 // 11. Single instance will not start a new task even with multiple task on
                 mSingleInstanceActivitySequence
                         .act(mSingleInstanceIntent.withFlags(NEW_DOCUMENT, MULTIPLE_TASK)),
                 // 12. The same should happen for single task.
                 mSingleTaskActivitySequence.act(
                         mSingleTaskIntent.withFlags(NEW_DOCUMENT, MULTIPLE_TASK))
         );
     }

     public List<LaunchSequence> clearCases() {
         LaunchSequence doubleRegularActivity = mRegularSequence.append(mRegularIntent);

         return Lists.newArrayList(
                 // 1. This will clear the bottom and end up with just one activity
                 mRegularSequence.act(mRegularIntent.withFlags(CLEAR_TOP)),
                 // 2. This will result in still two regulars
                 doubleRegularActivity.act(mRegularIntent.withFlags(CLEAR_TOP)),
                 // 3. This will result in a single regular it clears the top regular
                 // activity and then fails to start a new regular activity because it is already
                 // at the root of the task
                 doubleRegularActivity.act(mRegularIntent.withFlags(CLEAR_TOP, NEW_TASK)),
                 // 3. This will also result in two regulars, showing the first difference between
                 // new document and new task.
                 doubleRegularActivity.act(mRegularIntent.withFlags(CLEAR_TOP, NEW_DOCUMENT)),
                 // 4. This is here to show that previous is top has no effect on clear top or single
                 // top
                 doubleRegularActivity.act(mRegularIntent.withFlags(CLEAR_TOP, PREVIOUS_IS_TOP)),
                 // 5. Clear top finds the same activity in the task and clears from there
                 mRegularSequence.append(mAff1Intent).append(mRegularIntent).act(
                         mAff1Intent.withFlags(CLEAR_TOP))
         );
     }

     /**
      * Tests for {@link android.app.Activity#startActivityForResult(Intent, int)}
      */
     //TODO: If b/122968776 is fixed these tests need to be updated
     public List<LaunchSequence> forResultCases() {
         LaunchIntent singleTopForResult = intentForResult(Activities.SingleTopActivity.class);

         return Lists.newArrayList(
                 // 1. Start just a single regular activity
                 mRegularSequence.act(mRegularIntent.withFlags(SINGLE_TOP)),
                 // 2. For result will start a second activity
                 mRegularSequence.act(mRegularForResultIntent.withFlags(SINGLE_TOP)),
                 // 3. The same but for SINGLE_TOP as a launch mode
                 LaunchSequence.create(mSingleTopIntent).act(mSingleTopIntent),
                 // 4. Launch mode SINGLE_TOP when launched for result also starts a second activity.
                 LaunchSequence.create(mSingleTopIntent).act(singleTopForResult),
                 // 5. CLEAR_TOP results in a single regular activity
                 mRegularSequence.act(mRegularIntent.withFlags(CLEAR_TOP)),
                 // 6. Clear will still kill the for result
                 mRegularSequence.act(mRegularForResultIntent.withFlags(CLEAR_TOP)),
                 // 7. An activity started for result can go to a different task
                 mRegularSequence.act(mRegularForResultIntent.withFlags(NEW_TASK, MULTIPLE_TASK)),
                 // 8. Reorder to front with for result
                 mRegularSequence.append(mAff1Intent).act(
                         mRegularForResultIntent.withFlags(REORDER_TO_FRONT)),
                 // 9. Reorder can move an activity above one that it started for result
                 mRegularSequence.append(intentForResult(Activities.TaskAffinity1Activity.class))
                         .act(mRegularIntent.withFlags(REORDER_TO_FRONT))
         );
     }

     /**
      * Reset task if needed will trigger when it is delivered with new task set
      * and there are activities in the task that have a different affinity.
      *
      * @return the test cases
      */
     //TODO: If b/122324373 is fixed these test need to be updated.
     public List<LaunchSequence> resetTaskIfNeeded() {
         // If a task with a different affinity like this get's reset
         // it will create another task in the same stack with the now orphaned activity.
         LaunchIntent resetRegularTask = mRegularIntent.withFlags(NEW_TASK,
                 RESET_TASK_IF_NEEDED);
         LaunchSequence resetIfNeeded = mRegularSequence.append(mAff1Intent)
                 .act(resetRegularTask);

         // If you try to reset a task with an activity that was started for result
         // it will not move task.
         LaunchSequence resetWontMoveResult = mRegularSequence.append(
                 intentForResult(Activities.TaskAffinity1Activity.class))
                 .act(resetRegularTask);

         // Reset will not move activities with to a task with that affinity,
         // instead it will always create a new task in that stack.
         LaunchSequence resetToExistingTask2 = mRegularSequence
                 .append(mAff1Intent)
                 .append(mAff1Intent.withFlags(NEW_TASK))
                 .act(resetRegularTask);

         // If a reset occurs the activities that move retain the same order
         // in the new task as they had in the old task.
         LaunchSequence resetOrdering = mRegularSequence
                 .append(mAff1Intent)
                 .append(mSecondAff1Intent)
                 .act(resetRegularTask);

         return Lists.newArrayList(resetIfNeeded, resetWontMoveResult, resetToExistingTask2,
                 resetOrdering);
     }

     /**
      * The human readable flags in the JSON files need to be converted back to the corresponding
      * IntentFlag object when reading the file. This creates a map from the flags to their
      * corresponding object.
      *
      * @return lookup table for the parsing of intent flags in the json files.
      */
     public Map<String, IntentFlag> createFlagParsingTable() {
         HashMap<String, IntentFlag> flags = new HashMap<>();
         for (IntentFlag flag : this.flags) {
             flags.put(flag.name, flag);
         }

         flags.put(NONE.getName(), NONE);
         return flags;
     }
 }
	/*
	* Copyright (C) 2019 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 android.server.wm.intent;

	import static android.content.Intent.FLAG_ACTIVITY_CLEAR_TASK;
	import static android.content.Intent.FLAG_ACTIVITY_CLEAR_TOP;
	import static android.content.Intent.FLAG_ACTIVITY_MULTIPLE_TASK;
	import static android.content.Intent.FLAG_ACTIVITY_NEW_DOCUMENT;
	import static android.content.Intent.FLAG_ACTIVITY_NEW_TASK;
	import static android.content.Intent.FLAG_ACTIVITY_NO_HISTORY;
	import static android.content.Intent.FLAG_ACTIVITY_PREVIOUS_IS_TOP;
	import static android.content.Intent.FLAG_ACTIVITY_REORDER_TO_FRONT;
	import static android.content.Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED;
	import static android.content.Intent.FLAG_ACTIVITY_SINGLE_TOP;
	import static android.server.wm.intent.LaunchSequence.intent;
	import static android.server.wm.intent.LaunchSequence.intentForResult;
	import static android.server.wm.intent.Persistence.flag;

	import android.content.Intent;
	import android.server.wm.intent.Activities.RegularActivity;
	import android.server.wm.intent.Persistence.IntentFlag;
	import android.server.wm.intent.Persistence.LaunchIntent;

	import com.google.common.collect.Lists;

	import java.util.HashMap;
	import java.util.List;
	import java.util.Map;

	/**
	* Contains all information to create and reuse intent test launches.
	* It enumerates all the flags so they can easily be used.
	*
	* It also stores commonly used {@link LaunchSequence} objects for reuse.
	*/
	public class Cases {

	public static final IntentFlag CLEAR_TASK = flag(FLAG_ACTIVITY_CLEAR_TASK,
	"FLAG_ACTIVITY_CLEAR_TASK");
	public static final IntentFlag CLEAR_TOP = flag(FLAG_ACTIVITY_CLEAR_TOP,
	"FLAG_ACTIVITY_CLEAR_TOP");
	private static final IntentFlag SINGLE_TOP = flag(FLAG_ACTIVITY_SINGLE_TOP,
	"FLAG_ACTIVITY_SINGLE_TOP");
	public static final IntentFlag NEW_TASK = flag(FLAG_ACTIVITY_NEW_TASK,
	"FLAG_ACTIVITY_NEW_TASK");
	public static final IntentFlag NEW_DOCUMENT = flag(FLAG_ACTIVITY_NEW_DOCUMENT,
	"FLAG_ACTIVITY_NEW_DOCUMENT");
	private static final IntentFlag MULTIPLE_TASK = flag(FLAG_ACTIVITY_MULTIPLE_TASK,
	"FLAG_ACTIVITY_MULTIPLE_TASK");
	public static final IntentFlag RESET_TASK_IF_NEEDED = flag(
	FLAG_ACTIVITY_RESET_TASK_IF_NEEDED,
	"FLAG_ACTIVITY_RESET_TASK_IF_NEEDED");
	public static final IntentFlag PREVIOUS_IS_TOP = flag(FLAG_ACTIVITY_PREVIOUS_IS_TOP,
	"FLAG_ACTIVITY_PREVIOUS_IS_TOP");
	public static final IntentFlag REORDER_TO_FRONT = flag(FLAG_ACTIVITY_REORDER_TO_FRONT,
	"FLAG_ACTIVITY_REORDER_TO_FRONT");
	public static final IntentFlag NO_HISTORY = flag(FLAG_ACTIVITY_NO_HISTORY,
	"FLAG_ACTIVITY_NO_HISTORY");

	// Flag only used for parsing intents that contain no flags.
	private static final IntentFlag NONE = flag(0, "");

	public final List<IntentFlag> flags = Lists.newArrayList(
	CLEAR_TASK,
	CLEAR_TOP,
	SINGLE_TOP,
	NEW_TASK,
	NEW_DOCUMENT,
	MULTIPLE_TASK,
	RESET_TASK_IF_NEEDED,
	PREVIOUS_IS_TOP,
	REORDER_TO_FRONT,
	NO_HISTORY
	);

	// Definition of intents used across multiple test cases.
	private final LaunchIntent mRegularIntent = intent(RegularActivity.class);
	private final LaunchIntent mSingleTopIntent = intent(Activities.SingleTopActivity.class);
	private final LaunchIntent mAff1Intent = intent(Activities.TaskAffinity1Activity.class);
	private final LaunchIntent mSecondAff1Intent = intent(Activities.TaskAffinity1Activity2.class);
	private final LaunchIntent mSingleInstanceIntent = intent(
	Activities.SingleInstanceActivity.class);
	private final LaunchIntent mSingleTaskIntent = intent(Activities.SingleTaskActivity.class);
	private final LaunchIntent mRegularForResultIntent = intentForResult(RegularActivity.class);

	// LaunchSequences used across multiple test cases.
	private final LaunchSequence mRegularSequence = LaunchSequence.create(mRegularIntent);

	// To show that the most recent task get's resumed by new task
	private final LaunchSequence mTwoAffinitiesSequence =
	LaunchSequence.create(mAff1Intent)
	.append(mRegularIntent)
	.append(mAff1Intent.withFlags(NEW_TASK, MULTIPLE_TASK));

	// Used to show that the task affinity is determined by the activity that started it,
	// Not the affinity of the current root activity.
	private final LaunchSequence mRearrangedRootSequence = LaunchSequence.create(mRegularIntent)
	.append(mAff1Intent.withFlags(NEW_TASK))
	.append(mRegularIntent)
	.append(mAff1Intent.withFlags(REORDER_TO_FRONT));


	private final LaunchSequence mSingleInstanceActivitySequence =
	LaunchSequence.create(mSingleInstanceIntent);

	private final LaunchSequence mSingleTaskActivitySequence = LaunchSequence.create(
	mSingleTaskIntent);

	public List<LaunchSequence> newTaskCases() {
	LaunchIntent aff1NewTask = mAff1Intent.withFlags(NEW_TASK);

	return Lists.newArrayList(
	// 1. Single instance will start a new task even without new task set
	mRegularSequence.act(mSingleInstanceIntent),
	// 2. With new task it will still end up in a new task
	mRegularSequence.act(mSingleInstanceIntent.withFlags(NEW_TASK)),
	// 3. Starting an activity with a different affinity without new task will put it in
	// the existing task
	mRegularSequence.act(mAff1Intent),
	// 4. Starting a task with a different affinity and new task will start a new task
	mRegularSequence.act(aff1NewTask),
	// 5. Starting the intent with new task will not add a new activity to the task
	mRegularSequence.act(mRegularIntent.withFlags(NEW_TASK)),
	// 6. A different activity with the same affinity will start a new activity in
	// the sam task
	mRegularSequence.act(mSingleTopIntent.withFlags(NEW_TASK)),
	// 7. To show that the most recent task get's resumed by new task, this can't
	// be observed without differences in the same activity / task
	mTwoAffinitiesSequence.act(aff1NewTask),
	// 8. To show that new task respects the root as a single even
	// if it is not at the bottom
	mRearrangedRootSequence.act(mAff1Intent.withFlags(NEW_TASK)),
	// 9. To show that new task with non root does start a new activity.
	mRearrangedRootSequence.act(mSecondAff1Intent.withFlags(NEW_TASK)),
	// 10. Multiple task will allow starting activities of the same affinity in
	// different tasks
	mRegularSequence.act(mRegularIntent.withFlags(NEW_TASK, MULTIPLE_TASK)),
	// 11. Single instance will not start a new task even with multiple task on
	mSingleInstanceActivitySequence.act(
	mSingleInstanceIntent.withFlags(NEW_TASK, MULTIPLE_TASK)),
	// 12. The same should happen for single task.
	mSingleTaskActivitySequence.act(
	mSingleTaskIntent.withFlags(NEW_TASK, MULTIPLE_TASK)),
	// 13. This starts a regular in a new task
	mSingleInstanceActivitySequence.act(mRegularIntent),
	// 14. This adds regular in the same task
	mSingleTaskActivitySequence.act(mRegularIntent),
	// 15. Starting the activity for result keeps it in the same task
	mSingleInstanceActivitySequence.act(mRegularForResultIntent),
	// 16. Restarts the previous task with regular activity.
	mRegularSequence.append(mSingleInstanceIntent).act(mRegularIntent)
	);
	}

	/**
	* {@link android.content.Intent#FLAG_ACTIVITY_NEW_DOCUMENT }test cases are the same as
	* {@link Cases#newTaskCases()}, we should check them for differences.
	*/
	public List<LaunchSequence> newDocumentCases() {
	LaunchIntent aff1NewDocument = mAff1Intent.withFlags(NEW_DOCUMENT);

	return Lists.newArrayList(
	// 1. Single instance will start a new task even without new task set
	mRegularSequence.act(mSingleInstanceIntent),
	// 2. With new task it will still end up in a new task
	mRegularSequence.act(mSingleInstanceIntent.withFlags(NEW_DOCUMENT)),
	// 3. Starting an activity with a different affinity without new task will put it
	// in the existing task
	mRegularSequence.act(mAff1Intent),
	// 4. With new document it will start it's own task
	mRegularSequence.act(aff1NewDocument),
	// 5. Starting the intent with new task will not add a new activity to the task
	mRegularSequence.act(mRegularIntent.withFlags(NEW_DOCUMENT)),
	// 6. Unlike the case with NEW_TASK, with new Document
	mRegularSequence.act(mSingleTopIntent.withFlags(NEW_DOCUMENT)),
	// 7. To show that the most recent task get's resumed by new task
	mTwoAffinitiesSequence.act(aff1NewDocument),
	// 8. To show that new task respects the root as a single
	mRearrangedRootSequence.act(mAff1Intent.withFlags(NEW_DOCUMENT)),
	// 9. New document starts a third task here, because there was no task for the
	// document yet
	mRearrangedRootSequence.act(mSecondAff1Intent.withFlags(NEW_DOCUMENT)),
	// 10. Multiple task wil allow starting activities of the same affinity in different
	// tasks
	mRegularSequence.act(mRegularIntent.withFlags(NEW_DOCUMENT, MULTIPLE_TASK)),
	// 11. Single instance will not start a new task even with multiple task on
	mSingleInstanceActivitySequence
	.act(mSingleInstanceIntent.withFlags(NEW_DOCUMENT, MULTIPLE_TASK)),
	// 12. The same should happen for single task.
	mSingleTaskActivitySequence.act(
	mSingleTaskIntent.withFlags(NEW_DOCUMENT, MULTIPLE_TASK))
	);
	}

	public List<LaunchSequence> clearCases() {
	LaunchSequence doubleRegularActivity = mRegularSequence.append(mRegularIntent);

	return Lists.newArrayList(
	// 1. This will clear the bottom and end up with just one activity
	mRegularSequence.act(mRegularIntent.withFlags(CLEAR_TOP)),
	// 2. This will result in still two regulars
	doubleRegularActivity.act(mRegularIntent.withFlags(CLEAR_TOP)),
	// 3. This will result in a single regular it clears the top regular
	// activity and then fails to start a new regular activity because it is already
	// at the root of the task
	doubleRegularActivity.act(mRegularIntent.withFlags(CLEAR_TOP, NEW_TASK)),
	// 3. This will also result in two regulars, showing the first difference between
	// new document and new task.
	doubleRegularActivity.act(mRegularIntent.withFlags(CLEAR_TOP, NEW_DOCUMENT)),
	// 4. This is here to show that previous is top has no effect on clear top or single
	// top
	doubleRegularActivity.act(mRegularIntent.withFlags(CLEAR_TOP, PREVIOUS_IS_TOP)),
	// 5. Clear top finds the same activity in the task and clears from there
	mRegularSequence.append(mAff1Intent).append(mRegularIntent).act(
	mAff1Intent.withFlags(CLEAR_TOP))
	);
	}

	/**
	* Tests for {@link android.app.Activity#startActivityForResult(Intent, int)}
	*/
	//TODO: If b/122968776 is fixed these tests need to be updated
	public List<LaunchSequence> forResultCases() {
	LaunchIntent singleTopForResult = intentForResult(Activities.SingleTopActivity.class);

	return Lists.newArrayList(
	// 1. Start just a single regular activity
	mRegularSequence.act(mRegularIntent.withFlags(SINGLE_TOP)),
	// 2. For result will start a second activity
	mRegularSequence.act(mRegularForResultIntent.withFlags(SINGLE_TOP)),
	// 3. The same but for SINGLE_TOP as a launch mode
	LaunchSequence.create(mSingleTopIntent).act(mSingleTopIntent),
	// 4. Launch mode SINGLE_TOP when launched for result also starts a second activity.
	LaunchSequence.create(mSingleTopIntent).act(singleTopForResult),
	// 5. CLEAR_TOP results in a single regular activity
	mRegularSequence.act(mRegularIntent.withFlags(CLEAR_TOP)),
	// 6. Clear will still kill the for result
	mRegularSequence.act(mRegularForResultIntent.withFlags(CLEAR_TOP)),
	// 7. An activity started for result can go to a different task
	mRegularSequence.act(mRegularForResultIntent.withFlags(NEW_TASK, MULTIPLE_TASK)),
	// 8. Reorder to front with for result
	mRegularSequence.append(mAff1Intent).act(
	mRegularForResultIntent.withFlags(REORDER_TO_FRONT)),
	// 9. Reorder can move an activity above one that it started for result
	mRegularSequence.append(intentForResult(Activities.TaskAffinity1Activity.class))
	.act(mRegularIntent.withFlags(REORDER_TO_FRONT))
	);
	}

	/**
	* Reset task if needed will trigger when it is delivered with new task set
	* and there are activities in the task that have a different affinity.
	*
	* @return the test cases
	*/
	//TODO: If b/122324373 is fixed these test need to be updated.
	public List<LaunchSequence> resetTaskIfNeeded() {
	// If a task with a different affinity like this get's reset
	// it will create another task in the same stack with the now orphaned activity.
	LaunchIntent resetRegularTask = mRegularIntent.withFlags(NEW_TASK,
	RESET_TASK_IF_NEEDED);
	LaunchSequence resetIfNeeded = mRegularSequence.append(mAff1Intent)
	.act(resetRegularTask);

	// If you try to reset a task with an activity that was started for result
	// it will not move task.
	LaunchSequence resetWontMoveResult = mRegularSequence.append(
	intentForResult(Activities.TaskAffinity1Activity.class))
	.act(resetRegularTask);

	// Reset will not move activities with to a task with that affinity,
	// instead it will always create a new task in that stack.
	LaunchSequence resetToExistingTask2 = mRegularSequence
	.append(mAff1Intent)
	.append(mAff1Intent.withFlags(NEW_TASK))
	.act(resetRegularTask);

	// If a reset occurs the activities that move retain the same order
	// in the new task as they had in the old task.
	LaunchSequence resetOrdering = mRegularSequence
	.append(mAff1Intent)
	.append(mSecondAff1Intent)
	.act(resetRegularTask);

	return Lists.newArrayList(resetIfNeeded, resetWontMoveResult, resetToExistingTask2,
	resetOrdering);
	}

	/**
	* The human readable flags in the JSON files need to be converted back to the corresponding
	* IntentFlag object when reading the file. This creates a map from the flags to their
	* corresponding object.
	*
	* @return lookup table for the parsing of intent flags in the json files.
	*/
	public Map<String, IntentFlag> createFlagParsingTable() {
	HashMap<String, IntentFlag> flags = new HashMap<>();
	for (IntentFlag flag : this.flags) {
	flags.put(flag.name, flag);
	}

	flags.put(NONE.getName(), NONE);
	return flags;
	}
	}