xref: /aosp_15_r20/tools/acloud/create/avd_spec_test.py (revision 800a58d989c669b8eb8a71d8df53b1ba3d411444)

# Copyright 2018 - 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.
"""Tests for avd_spec."""

import glob
import os
import subprocess
import unittest

from unittest import mock

from acloud import errors
from acloud.create import avd_spec
from acloud.internal import constants
from acloud.internal.lib import android_build_client
from acloud.internal.lib import auth
from acloud.internal.lib import driver_test_lib
from acloud.internal.lib import utils
from acloud.list import list as list_instances
from acloud.public import config


# pylint: disable=invalid-name,protected-access
class AvdSpecTest(driver_test_lib.BaseDriverTest):
    """Test avd_spec methods."""

    def setUp(self):
        """Initialize new avd_spec.AVDSpec."""
        super().setUp()
        self.args = mock.MagicMock()
        self.args.flavor = ""
        self.args.local_image = None
        self.args.local_kernel_image = None
        self.args.local_system_image = None
        self.args.local_vendor_boot_image = None
        self.args.config_file = ""
        self.args.build_target = "fake_build_target"
        self.args.adb_port = None
        self.args.launch_args = None
        self.Patch(list_instances, "ChooseOneRemoteInstance", return_value=mock.MagicMock())
        self.Patch(list_instances, "GetInstancesFromInstanceNames", return_value=mock.MagicMock())

        # Setup mock Acloud config for usage in tests.
        self.mock_config = mock.MagicMock()
        self.mock_config.launch_args = None
        self.Patch(config, 'GetAcloudConfig', return_value=self.mock_config)

        self.AvdSpec = avd_spec.AVDSpec(self.args)

    # pylint: disable=protected-access
    def testProcessLocalImageArgs(self):
        """Test process args.local_image."""
        self.Patch(glob, "glob", return_value=["fake.img"])
        expected_image_artifact = "/path/cf_x86_phone-img-eng.user.zip"
        expected_image_dir = "/path-to-image-dir"
        self.Patch(os.path, "exists",
                   side_effect=lambda path: path in (expected_image_artifact,
                                                     expected_image_dir))
        self.Patch(os.path, "isdir",
                   side_effect=lambda path: path == expected_image_dir)
        self.Patch(os.path, "isfile",
                   side_effect=lambda path: path == expected_image_artifact)

        # Specified --local-image to a local zipped image file
        self.args.local_image = "/path/cf_x86_phone-img-eng.user.zip"
        self.AvdSpec._avd_type = constants.TYPE_CF
        self.AvdSpec._instance_type = constants.INSTANCE_TYPE_REMOTE
        self.AvdSpec._ProcessLocalImageArgs(self.args)
        self.assertEqual(self.AvdSpec._local_image_artifact,
                         expected_image_artifact)

        # Specified --local-image to a dir contains images
        self.Patch(utils, "GetBuildEnvironmentVariable",
                   return_value="test_cf_x86")
        self.args.local_image = "/path-to-image-dir"
        self.AvdSpec._avd_type = constants.TYPE_CF
        self.AvdSpec._instance_type = constants.INSTANCE_TYPE_REMOTE
        self.AvdSpec._ProcessLocalImageArgs(self.args)
        self.assertEqual(self.AvdSpec._local_image_dir, expected_image_dir)

        # Specified local_image without arg
        self.args.local_image = constants.FIND_IN_BUILD_ENV
        self.Patch(utils, "GetBuildEnvironmentVariable",
                   side_effect=["cf_x86_auto", "test_environ", "test_environ"])
        self.AvdSpec._ProcessLocalImageArgs(self.args)
        self.assertEqual(self.AvdSpec._local_image_dir, "test_environ")
        self.assertEqual(self.AvdSpec.local_image_artifact, expected_image_artifact)

        # Specified --avd-type=goldfish --local-image with a dir
        self.Patch(utils, "GetBuildEnvironmentVariable",
                   return_value="test_environ")
        self.args.local_image = "/path-to-image-dir"
        self.AvdSpec._avd_type = constants.TYPE_GF
        self.AvdSpec._instance_type = constants.INSTANCE_TYPE_LOCAL
        self.AvdSpec._ProcessLocalImageArgs(self.args)
        self.assertEqual(self.AvdSpec._local_image_dir, expected_image_dir)

    def testProcessLocalMixedImageArgs(self):
        """Test process args.local_kernel_image and args.local_system_image."""
        expected_image_dir = "/path-to-image-dir"
        expected_image_file = "/path-to-image-file"
        self.Patch(os.path, "exists",
                   side_effect=lambda path: path in (expected_image_file,
                                                     expected_image_dir))
        self.Patch(os.path, "isdir",
                   side_effect=lambda path: path == expected_image_dir)
        self.Patch(os.path, "isfile",
                   side_effect=lambda path: path == expected_image_file)

        # Specified --local-*-image with dirs.
        self.args.local_kernel_image = expected_image_dir
        self.args.local_system_image = expected_image_dir
        self.args.local_system_dlkm_image = expected_image_dir
        self.args.local_vendor_image = expected_image_dir
        self.AvdSpec._ProcessImageArgs(self.args)
        self.assertEqual(self.AvdSpec.local_kernel_image, expected_image_dir)
        self.assertEqual(self.AvdSpec.local_system_image, expected_image_dir)
        self.assertEqual(self.AvdSpec.local_system_dlkm_image, expected_image_dir)
        self.assertEqual(self.AvdSpec.local_vendor_image, expected_image_dir)

        # Specified --local-*-image with files.
        self.args.local_kernel_image = expected_image_file
        self.args.local_system_image = expected_image_file
        self.args.local_system_dlkm_image = expected_image_file
        self.args.local_vendor_boot_image = expected_image_file
        self.AvdSpec._ProcessImageArgs(self.args)
        self.assertEqual(self.AvdSpec.local_kernel_image, expected_image_file)
        self.assertEqual(self.AvdSpec.local_system_image, expected_image_file)
        self.assertEqual(self.AvdSpec.local_system_dlkm_image, expected_image_file)
        self.assertEqual(self.AvdSpec.local_vendor_boot_image, expected_image_file)

        # Specified --local-*-image without args.
        self.args.local_kernel_image = constants.FIND_IN_BUILD_ENV
        self.args.local_system_image = constants.FIND_IN_BUILD_ENV
        self.args.local_system_dlkm_image = constants.FIND_IN_BUILD_ENV
        self.args.local_vendor_image = constants.FIND_IN_BUILD_ENV
        with mock.patch("acloud.create.avd_spec.utils."
                        "GetBuildEnvironmentVariable",
                        return_value=expected_image_dir):
            self.AvdSpec._ProcessImageArgs(self.args)
        self.assertEqual(self.AvdSpec.local_kernel_image, expected_image_dir)
        self.assertEqual(self.AvdSpec.local_system_image, expected_image_dir)
        self.assertEqual(self.AvdSpec.local_system_dlkm_image, expected_image_dir)
        self.assertEqual(self.AvdSpec.local_vendor_image, expected_image_dir)

    def testProcessAutoconnect(self):
        """Test process autoconnect."""
        self.AvdSpec._autoconnect = False
        self.AvdSpec._ProcessAutoconnect()
        self.assertEqual(self.AvdSpec._autoconnect, False)

        self.AvdSpec._avd_type = constants.TYPE_CF
        self.AvdSpec._autoconnect = "webrtc"
        self.AvdSpec._ProcessAutoconnect()
        self.assertEqual(self.AvdSpec._autoconnect, "webrtc")

        self.AvdSpec._autoconnect = "vnc"
        self.AvdSpec._ProcessAutoconnect()
        self.assertEqual(self.AvdSpec._autoconnect, "vnc")

        self.AvdSpec._avd_type = constants.TYPE_GF
        self.AvdSpec._autoconnect = "webrtc"
        self.AvdSpec._ProcessAutoconnect()
        self.assertEqual(self.AvdSpec._autoconnect, "vnc")

    def testProcessImageArgs(self):
        """Test process image source."""
        self.Patch(glob, "glob", return_value=["fake.img"])
        # No specified local_image, image source is from remote
        self.AvdSpec._ProcessImageArgs(self.args)
        self.assertEqual(self.AvdSpec._image_source, constants.IMAGE_SRC_REMOTE)
        self.assertEqual(self.AvdSpec._local_image_dir, None)
        self.assertEqual(self.AvdSpec.local_kernel_image, None)
        self.assertEqual(self.AvdSpec.local_system_image, None)

        # Specified local_image with an arg for cf type
        self.Patch(os.path, "isfile", return_value=True)
        self.args.local_image = "/test_path/cf_x86_phone-img-eng.user.zip"
        self.AvdSpec._avd_type = constants.TYPE_CF
        self.AvdSpec._instance_type = constants.INSTANCE_TYPE_REMOTE
        self.AvdSpec._ProcessImageArgs(self.args)
        self.assertEqual(self.AvdSpec._image_source, constants.IMAGE_SRC_LOCAL)
        self.assertEqual(self.AvdSpec._local_image_artifact,
                         "/test_path/cf_x86_phone-img-eng.user.zip")

        # Specified local_image with an arg for gce type
        self.Patch(os.path, "isfile", return_value=False)
        self.Patch(os.path, "exists", return_value=True)
        self.args.local_image = "/test_path_to_dir/"
        self.AvdSpec._avd_type = constants.TYPE_GCE
        self.AvdSpec._ProcessImageArgs(self.args)
        self.assertEqual(self.AvdSpec._image_source, constants.IMAGE_SRC_LOCAL)
        self.assertEqual(self.AvdSpec._local_image_artifact,
                         "/test_path_to_dir/avd-system.tar.gz")

    @mock.patch.object(avd_spec.AVDSpec, "_GetGitRemote")
    def testGetBranchFromRepo(self, mock_gitremote):
        """Test get branch name from repo info."""
        # Check aosp repo gets proper branch prefix.
        fake_subprocess = mock.MagicMock()
        fake_subprocess.stdout = mock.MagicMock()
        fake_subprocess.stdout.readline = mock.MagicMock(return_value='')
        fake_subprocess.poll = mock.MagicMock(return_value=0)
        fake_subprocess.returncode = 0
        return_value = "Manifest branch: fake_branch"
        fake_subprocess.communicate = mock.MagicMock(return_value=(return_value, ''))
        self.Patch(subprocess, "Popen", return_value=fake_subprocess)

        mock_gitremote.return_value = "aosp"
        self.assertEqual(self.AvdSpec._GetBranchFromRepo(), "aosp-fake_branch")

        # Check default repo gets default branch prefix.
        mock_gitremote.return_value = ""
        return_value = "Manifest branch: fake_branch"
        fake_subprocess.communicate = mock.MagicMock(return_value=(return_value, ''))
        self.Patch(subprocess, "Popen", return_value=fake_subprocess)
        self.assertEqual(self.AvdSpec._GetBranchFromRepo(), "git_fake_branch")

        # Can't get branch from repo info, set it as default branch.
        return_value = "Manifest branch:"
        fake_subprocess.communicate = mock.MagicMock(return_value=(return_value, ''))
        self.Patch(subprocess, "Popen", return_value=fake_subprocess)
        self.assertEqual(self.AvdSpec._GetBranchFromRepo(), "aosp-main")

    def testGetBuildBranch(self):
        """Test GetBuildBranch function"""
        # Test infer branch from build_id and build_target.
        build_client = mock.MagicMock()
        build_id = "fake_build_id"
        build_target = "fake_build_target"
        expected_branch = "fake_build_branch"
        self.Patch(android_build_client, "AndroidBuildClient",
                   return_value=build_client)
        self.Patch(auth, "CreateCredentials", return_value=mock.MagicMock())
        self.Patch(build_client, "GetBranch", return_value=expected_branch)
        self.assertEqual(self.AvdSpec._GetBuildBranch(build_id, build_target),
                         expected_branch)
        # Infer branch from "repo info" when build_id and build_target is None.
        self.Patch(self.AvdSpec, "_GetBranchFromRepo", return_value="repo_branch")
        build_id = None
        build_target = None
        expected_branch = "repo_branch"
        self.assertEqual(self.AvdSpec._GetBuildBranch(build_id, build_target),
                         expected_branch)

    # pylint: disable=protected-access
    def testGetBuildTarget(self):
        """Test get build target name."""
        branch = "git_branch"
        self.AvdSpec._flavor = constants.FLAVOR_IOT
        self.args.avd_type = constants.TYPE_GCE
        self.assertEqual(
            self.AvdSpec._GetBuildTarget(self.args, branch),
            "gce_x86_64_iot-userdebug")

        branch = "aosp-master"
        self.AvdSpec._flavor = constants.FLAVOR_PHONE
        self.args.avd_type = constants.TYPE_CF
        self.assertEqual(
            self.AvdSpec._GetBuildTarget(self.args, branch),
            "aosp_cf_x86_64_phone-userdebug")

        branch = "aosp-main"
        self.AvdSpec._flavor = constants.FLAVOR_PHONE
        self.args.avd_type = constants.TYPE_CF
        self.assertEqual(
            self.AvdSpec._GetBuildTarget(self.args, branch),
            "aosp_cf_x86_64_phone-trunk_staging-userdebug")

        branch = "git_branch"
        self.AvdSpec._flavor = constants.FLAVOR_PHONE
        self.args.avd_type = constants.TYPE_CF
        self.assertEqual(
            self.AvdSpec._GetBuildTarget(self.args, branch),
            "cf_x86_64_phone-userdebug")

    # pylint: disable=protected-access
    def testProcessHWPropertyWithInvalidArgs(self):
        """Test _ProcessHWPropertyArgs with invalid args."""
        # Checking wrong resolution.
        args = mock.MagicMock()
        args.hw_property = "cpu:3,resolution:1280"
        args.reuse_instance_name = None
        with self.assertRaises(errors.InvalidHWPropertyError):
            self.AvdSpec._ProcessHWPropertyArgs(args)

        # Checking property should be int.
        args = mock.MagicMock()
        args.hw_property = "cpu:3,dpi:fake"
        with self.assertRaises(errors.InvalidHWPropertyError):
            self.AvdSpec._ProcessHWPropertyArgs(args)

        # Checking disk property should be with 'g' suffix.
        args = mock.MagicMock()
        args.hw_property = "cpu:3,disk:2"
        with self.assertRaises(errors.InvalidHWPropertyError):
            self.AvdSpec._ProcessHWPropertyArgs(args)

        # Checking memory property should be with 'g' suffix.
        args = mock.MagicMock()
        args.hw_property = "cpu:3,memory:2"
        with self.assertRaises(errors.InvalidHWPropertyError):
            self.AvdSpec._ProcessHWPropertyArgs(args)

    # pylint: disable=protected-access
    @mock.patch.object(utils, "PrintColorString")
    def testCheckCFBuildTarget(self, print_warning):
        """Test _CheckCFBuildTarget."""
        # patch correct env variable.
        self.Patch(utils, "GetBuildEnvironmentVariable",
                   return_value="cf_x86_phone-userdebug")
        self.AvdSpec._CheckCFBuildTarget(constants.INSTANCE_TYPE_REMOTE)
        self.AvdSpec._CheckCFBuildTarget(constants.INSTANCE_TYPE_LOCAL)

        self.Patch(utils, "GetBuildEnvironmentVariable",
                   return_value="aosp_cf_arm64_auto-userdebug")
        self.AvdSpec._CheckCFBuildTarget(constants.INSTANCE_TYPE_HOST)
        # patch wrong env variable.
        self.Patch(utils, "GetBuildEnvironmentVariable",
                   return_value="test_environ")
        self.AvdSpec._CheckCFBuildTarget(constants.INSTANCE_TYPE_REMOTE)

        print_warning.assert_called_once()

    # pylint: disable=protected-access
    def testParseHWPropertyStr(self):
        """Test _ParseHWPropertyStr."""
        expected_dict = {"cpu": "2", "x_res": "1080", "y_res": "1920",
                         "dpi": "240", "memory": "4096", "disk": "4096"}
        args_str = "cpu:2,resolution:1080x1920,dpi:240,memory:4g,disk:4g"
        result_dict = self.AvdSpec._ParseHWPropertyStr(args_str)
        self.assertTrue(expected_dict == result_dict)

        expected_dict = {"cpu": "2", "x_res": "1080", "y_res": "1920",
                         "dpi": "240", "memory": "512", "disk": "4096"}
        args_str = "cpu:2,resolution:1080x1920,dpi:240,memory:512m,disk:4g"
        result_dict = self.AvdSpec._ParseHWPropertyStr(args_str)
        self.assertTrue(expected_dict == result_dict)

    def testGetFlavorFromBuildTargetString(self):
        """Test _GetFlavorFromLocalImage."""
        img_path = "/fack_path/cf_x86_tv-img-eng.user.zip"
        self.assertEqual(self.AvdSpec._GetFlavorFromString(img_path),
                         "tv")

        build_target_str = "aosp_cf_x86_auto"
        self.assertEqual(self.AvdSpec._GetFlavorFromString(
            build_target_str), "auto")

        # Flavor is not supported.
        img_path = "/fack_path/cf_x86_error-img-eng.user.zip"
        self.assertEqual(self.AvdSpec._GetFlavorFromString(img_path),
                         None)

    # pylint: disable=protected-access,too-many-statements
    def testProcessRemoteBuildArgs(self):
        """Test _ProcessRemoteBuildArgs."""
        self.args.branch = "git_master"
        self.args.build_id = "1234"
        self.args.launch_args = None

        # Verify auto-assigned avd_type if build_targe contains "_gce_".
        self.args.build_target = "aosp_gce_x86_phone-userdebug"
        self.AvdSpec._ProcessRemoteBuildArgs(self.args)
        self.assertTrue(self.AvdSpec.avd_type == "gce")

        # Verify auto-assigned avd_type if build_targe contains "gce_".
        self.args.build_target = "gce_x86_phone-userdebug"
        self.AvdSpec._ProcessRemoteBuildArgs(self.args)
        self.assertTrue(self.AvdSpec.avd_type == "gce")

        # Verify auto-assigned avd_type if build_targe contains "_cf_".
        self.args.build_target = "aosp_cf_x86_64_phone-userdebug"
        self.AvdSpec._ProcessRemoteBuildArgs(self.args)
        self.assertTrue(self.AvdSpec.avd_type == "cuttlefish")

        # Verify auto-assigned avd_type if build_targe contains "cf_".
        self.args.build_target = "cf_x86_phone-userdebug"
        self.AvdSpec._ProcessRemoteBuildArgs(self.args)
        self.assertTrue(self.AvdSpec.avd_type == "cuttlefish")

        # Verify auto-assigned avd_type if build_targe contains "sdk_".
        self.args.build_target = "sdk_phone_armv7-sdk"
        self.AvdSpec._ProcessRemoteBuildArgs(self.args)
        self.assertTrue(self.AvdSpec.avd_type == "goldfish")

        # Verify auto-assigned avd_type if build_targe contains "_sdk_".
        self.args.build_target = "aosp_sdk_phone_armv7-sdk"
        self.AvdSpec._ProcessRemoteBuildArgs(self.args)
        self.assertTrue(self.AvdSpec.avd_type == "goldfish")

        # Verify auto-assigned avd_type if build_target contains "_trusty_".
        self.args.build_target = "qemu_trusty_arm64-trunk_staging-userdebug"
        self.AvdSpec._ProcessRemoteBuildArgs(self.args)
        self.assertTrue(self.AvdSpec.avd_type == "trusty")

        # Verify extra build info.
        self.args.system_branch = "system_branch"
        self.args.system_build_target = "system_build_target"
        self.args.system_build_id = "system_build_id"
        self.args.ota_branch = "ota_branch"
        self.args.ota_build_target = "ota_build_target"
        self.args.ota_build_id = "ota_build_id"
        self.args.kernel_branch = "kernel_branch"
        self.args.kernel_build_target = "kernel_build_target"
        self.args.kernel_build_id = "kernel_build_id"
        self.args.boot_branch = "boot_branch"
        self.args.boot_build_target = "boot_build_target"
        self.args.boot_build_id = "boot_build_id"
        self.args.boot_artifact = "boot_artifact"
        self.AvdSpec._ProcessRemoteBuildArgs(self.args)
        self.assertEqual(
            {constants.BUILD_BRANCH: "system_branch",
             constants.BUILD_TARGET: "system_build_target",
             constants.BUILD_ID: "system_build_id"},
            self.AvdSpec.system_build_info)
        self.assertEqual(
            {constants.BUILD_BRANCH: "kernel_branch",
             constants.BUILD_TARGET: "kernel_build_target",
             constants.BUILD_ID: "kernel_build_id"},
            self.AvdSpec.kernel_build_info)
        self.assertEqual(
            {constants.BUILD_BRANCH: "boot_branch",
             constants.BUILD_TARGET: "boot_build_target",
             constants.BUILD_ID: "boot_build_id",
             constants.BUILD_ARTIFACT: "boot_artifact"},
            self.AvdSpec.boot_build_info)
        self.assertEqual(
            {constants.BUILD_BRANCH: "ota_branch",
             constants.BUILD_TARGET: "ota_build_target",
             constants.BUILD_ID: "ota_build_id"},
            self.AvdSpec.ota_build_info)

        # Verify auto-assigned avd_type if no match, default as cuttlefish.
        self.args.build_target = "mini_emulator_arm64-userdebug"
        self.args.avd_type = "cuttlefish"
        # reset args.avd_type default value as cuttlefish.
        self.AvdSpec = avd_spec.AVDSpec(self.args)
        self.AvdSpec._ProcessRemoteBuildArgs(self.args)
        self.assertTrue(self.AvdSpec.avd_type == "cuttlefish")

    def testEscapeAnsi(self):
        """Test EscapeAnsi."""
        test_string = "\033[1;32;40m Manifest branch:"
        expected_result = " Manifest branch:"
        self.assertEqual(avd_spec.EscapeAnsi(test_string), expected_result)

    def testGetGceLocalImagePath(self):
        """Test get gce local image path."""
        self.Patch(os.path, "isfile", return_value=True)
        # Verify when specify --local-image ~/XXX.tar.gz.
        fake_image_path = "~/gce_local_image_dir/gce_image.tar.gz"
        self.Patch(os.path, "exists", return_value=True)
        self.assertEqual(self.AvdSpec._GetGceLocalImagePath(fake_image_path),
                         "~/gce_local_image_dir/gce_image.tar.gz")

        # Verify when specify --local-image ~/XXX.img.
        fake_image_path = "~/gce_local_image_dir/gce_image.img"
        self.assertEqual(self.AvdSpec._GetGceLocalImagePath(fake_image_path),
                         "~/gce_local_image_dir/gce_image.img")

        # Verify if exist argument --local-image as a directory.
        self.Patch(os.path, "isfile", return_value=False)
        self.Patch(os.path, "exists", return_value=True)
        fake_image_path = "~/gce_local_image_dir/"
        # Default to find */avd-system.tar.gz if exist then return the path.
        self.assertEqual(self.AvdSpec._GetGceLocalImagePath(fake_image_path),
                         "~/gce_local_image_dir/avd-system.tar.gz")

        # Otherwise choose raw file */android_system_disk_syslinux.img if
        # exist then return the path.
        self.Patch(os.path, "exists", side_effect=[False, True])
        self.assertEqual(self.AvdSpec._GetGceLocalImagePath(fake_image_path),
                         "~/gce_local_image_dir/android_system_disk_syslinux.img")

        # Both _GCE_LOCAL_IMAGE_CANDIDATE could not be found then raise error.
        self.Patch(os.path, "exists", side_effect=[False, False])
        self.assertRaises(errors.ImgDoesNotExist,
                          self.AvdSpec._GetGceLocalImagePath, fake_image_path)

    def testProcessMiscArgs(self):
        """Test process misc args."""
        self.args.remote_host = None
        self.args.local_instance = None
        self.AvdSpec._ProcessMiscArgs(self.args)
        self.assertEqual(self.AvdSpec._instance_type, constants.INSTANCE_TYPE_REMOTE)

        self.args.remote_host = None
        self.args.local_instance = 0
        self.AvdSpec._ProcessMiscArgs(self.args)
        self.assertEqual(self.AvdSpec._instance_type, constants.INSTANCE_TYPE_LOCAL)

        self.args.remote_host = "1.1.1.1"
        self.args.local_instance = None
        self.AvdSpec._ProcessMiscArgs(self.args)
        self.assertEqual(self.AvdSpec._instance_type, constants.INSTANCE_TYPE_HOST)

        self.args.remote_host = "1.1.1.1"
        self.args.local_instance = 1
        self.AvdSpec._ProcessMiscArgs(self.args)
        self.assertEqual(self.AvdSpec._instance_type, constants.INSTANCE_TYPE_HOST)

        self.args.oxygen = True
        self.AvdSpec._ProcessMiscArgs(self.args)
        self.assertTrue(self.AvdSpec._oxygen)

        # Test avd_spec.autoconnect
        self.args.autoconnect = False
        self.AvdSpec._ProcessMiscArgs(self.args)
        self.assertEqual(self.AvdSpec.autoconnect, False)
        self.assertEqual(self.AvdSpec.connect_adb, False)
        self.assertEqual(self.AvdSpec.connect_vnc, False)
        self.assertEqual(self.AvdSpec.connect_webrtc, False)

        self.args.autoconnect = constants.INS_KEY_VNC
        self.AvdSpec._ProcessMiscArgs(self.args)
        self.assertEqual(self.AvdSpec.autoconnect, True)
        self.assertEqual(self.AvdSpec.connect_adb, True)
        self.assertEqual(self.AvdSpec.connect_vnc, True)
        self.assertEqual(self.AvdSpec.connect_webrtc, False)

        self.args.autoconnect = constants.INS_KEY_ADB
        self.AvdSpec._ProcessMiscArgs(self.args)
        self.assertEqual(self.AvdSpec.autoconnect, True)
        self.assertEqual(self.AvdSpec.connect_adb, True)
        self.assertEqual(self.AvdSpec.connect_vnc, False)
        self.assertEqual(self.AvdSpec.connect_webrtc, False)

        self.args.autoconnect = constants.INS_KEY_WEBRTC
        self.AvdSpec._ProcessMiscArgs(self.args)
        self.assertEqual(self.AvdSpec.autoconnect, True)
        self.assertEqual(self.AvdSpec.connect_adb, True)
        self.assertEqual(self.AvdSpec.connect_vnc, False)
        self.assertEqual(self.AvdSpec.connect_webrtc, True)

        # Test stable host image name.
        self.args.stable_host_image_name = "fake_host_image"
        self.AvdSpec._ProcessMiscArgs(self.args)
        self.assertEqual(self.AvdSpec.stable_host_image_name, "fake_host_image")

        # Setup acloud config with betty_image spec
        self.mock_config.betty_image = 'from-config'
        # --betty-image from cmdline should override config
        self.args.cheeps_betty_image = 'from-cmdline'
        self.AvdSpec._ProcessMiscArgs(self.args)
        self.assertEqual(self.AvdSpec.cheeps_betty_image, 'from-cmdline')
        # acloud config value is used otherwise
        self.args.cheeps_betty_image = None
        self.AvdSpec._ProcessMiscArgs(self.args)
        self.assertEqual(self.AvdSpec.cheeps_betty_image, 'from-config')

        # Verify cheeps_features is assigned from args.
        self.args.cheeps_features = ['a', 'b', 'c']
        self.AvdSpec._ProcessMiscArgs(self.args)
        self.assertEqual(self.args.cheeps_features, ['a', 'b', 'c'])

        # Verify connect_hostname
        self.mock_config.connect_hostname = True
        self.AvdSpec._ProcessMiscArgs(self.args)
        self.assertTrue(self.AvdSpec.connect_hostname)
        self.args.connect_hostname = True
        self.mock_config.connect_hostname = False
        self.assertTrue(self.AvdSpec.connect_hostname)

        # Verify fetch_cvd_version
        self.args.fetch_cvd_build_id = None
        self.AvdSpec._ProcessMiscArgs(self.args)
        self.assertEqual(self.AvdSpec.fetch_cvd_version, "LKGB")

        self.args.fetch_cvd_build_id = "23456"
        self.AvdSpec._ProcessMiscArgs(self.args)
        self.assertEqual(self.AvdSpec.fetch_cvd_version, "23456")

        self.args.trusty_branch = "trusty_branch"
        self.args.trusty_build_id = "trusty_build_id"
        self.args.trusty_build_target = "trusty_build_target"
        self.AvdSpec._ProcessMiscArgs(self.args)
        self.assertEqual(
            {constants.BUILD_BRANCH: "trusty_branch",
             constants.BUILD_TARGET: "trusty_build_target",
             constants.BUILD_ID: "trusty_build_id"},
            self.AvdSpec.trusty_build_info)


if __name__ == "__main__":
    unittest.main()