Publish Vulpes Preview 15 sources for desktop, Android and Tundra

Share Gaia assets and adapters, keep private profiles and development documents local, and update both public READMEs.

gaia/apps/settings/test/marionette/tests/airplane_mode_settings_test.js

@@ -0,0 +1,57 @@
+'use strict';
+var Settings = require('../app/app'),
+    assert = require('assert');
+
+// Note :
+// This test is only run on devices
+marionette('airplaneMode settings', function() {
+  var client = marionette.client({
+    desiredCapabilities: { raisesAccessibilityExceptions: false }
+  });
+  var settingsApp;
+  var rootPanel;
+
+  setup(function() {
+    settingsApp = new Settings(client);
+    settingsApp.launch();
+    rootPanel = settingsApp.rootPanel;
+  });
+
+  suite('Turning airplaneMode from off to on', function() {
+    setup(function() {
+      prepareDefaultServices();
+      rootPanel.airplaneMode(false);
+    });
+
+    test('all related services will be turned off', function() {
+      rootPanel.airplaneMode(true);
+      assert.equal(rootPanel.wifiEnabledSetting, false);
+      assert.equal(rootPanel.bluetoothEnabledSetting, false);
+      assert.equal(rootPanel.geolocationCheckboxChecked, false);
+      assert.equal(rootPanel.nfcCheckboxChecked, false);
+    });
+  });
+
+  suite('Turning airplaneMode from on to off', function() {
+    setup(function() {
+      prepareDefaultServices();
+      rootPanel.airplaneMode(true);
+    });
+
+    test('all related services will be turned on', function() {
+      rootPanel.airplaneMode(false);
+      assert.equal(rootPanel.wifiEnabledSetting, true);
+      assert.equal(rootPanel.bluetoothEnabledSetting, true);
+      assert.equal(rootPanel.geolocationCheckboxChecked, true);
+      assert.equal(rootPanel.nfcCheckboxChecked, true);
+    });
+  });
+
+  function prepareDefaultServices() {
+    client.settings.set('airplaneMode.enabled', false);
+    client.settings.set('wifi.enabled', true);
+    client.settings.set('bluetooth.enabled', true);
+    client.settings.set('geolocation.enabled', true);
+    client.settings.set('nfc.enabled', true);
+  }
+});

gaia/apps/settings/test/marionette/tests/app_permission_settings_test.js

@@ -0,0 +1,23 @@
+'use strict';
+var Settings = require('../app/app'),
+    assert = require('assert');
+
+marionette('manipulate app permissions', function() {
+  var client = marionette.client({
+    desiredCapabilities: { raisesAccessibilityExceptions: false }
+  });
+  var settingsApp;
+  var appPermissionPanel;
+
+  setup(function() {
+    settingsApp = new Settings(client);
+    settingsApp.launch();
+    appPermissionPanel = settingsApp.appPermissionPanel;
+  });
+
+  test('set geolocation of first app to Grant', function() {
+    appPermissionPanel.enterPermissionDetail();
+    appPermissionPanel.tapGeolocationSelect('Grant');
+    assert.equal(appPermissionPanel.georlocationSelectValue, 'allow');
+  });
+});

gaia/apps/settings/test/marionette/tests/app_storage_settings_test.js

@@ -0,0 +1,28 @@
+'use strict';
+var Settings = require('../app/app'),
+    assert = require('assert');
+
+marionette('manipulate app storage settings', function() {
+  var client = marionette.client();
+  var settingsApp;
+  var appStoragePanel;
+
+  function gotoAppStoragePanel() {
+    settingsApp = new Settings(client);
+    settingsApp.launch();
+    // Navigate to the Support menu
+    appStoragePanel = settingsApp.appStoragePanel;
+  }
+
+  suite('check app storage basics', function() {
+    setup(function() {
+      gotoAppStoragePanel();
+    });
+
+    test('check storage data contain numbers', function() {
+      assert.ok(appStoragePanel.containNumberInAppTotalSpace);
+      assert.ok(appStoragePanel.containNumberInAppUsedSpace);
+      assert.ok(appStoragePanel.containNumberInAppFreeSpace);
+    });
+  });
+});

gaia/apps/settings/test/marionette/tests/battery_settings_test.js

@@ -0,0 +1,42 @@
+'use strict';
+var Settings = require('../app/app'),
+    assert = require('assert');
+
+marionette('manipulate battery settings', function() {
+  var client = marionette.client({
+    desiredCapabilities: { raisesAccessibilityExceptions: false }
+  });
+  var settingsApp;
+  var batteryPanel;
+
+  setup(function() {
+    settingsApp = new Settings(client);
+    settingsApp.launch();
+    // Navigate to the battery menu
+    batteryPanel = settingsApp.batteryPanel;
+  });
+
+  test('check power save mode initial state', function() {
+    assert.ok(
+      !batteryPanel.isPowerSavingEnabled,
+      'power save mode is disabled by default'
+    );
+  });
+
+  test('enable power save mode', function() {
+    batteryPanel.enablePowerSaveMode();
+    assert.ok(
+      batteryPanel.isPowerSavingEnabled,
+      'power save mode has been enabled'
+    );
+  });
+
+  test('open Turn On Period option selector', function() {
+    batteryPanel.changeTurnOnPeriod();
+    assert.ok(
+      batteryPanel.isLastOptionSelected,
+      'Turn On Period option can be tapped'
+    );
+  });
+
+});

gaia/apps/settings/test/marionette/tests/bluetooth_settings_test.js

@@ -0,0 +1,34 @@
+'use strict';
+var Settings = require('../app/app'),
+    assert = require('assert');
+
+marionette('manipulate bluetooth settings', function() {
+  var client = marionette.client({
+    desiredCapabilities: { raisesAccessibilityExceptions: false }
+  });
+  var settingsApp;
+  var bluetoothPanel;
+
+  setup(function() {
+    settingsApp = new Settings(client);
+    settingsApp.launch();
+    // Navigate to the Bluetooth menu
+    bluetoothPanel = settingsApp.bluetoothPanel;
+  });
+
+  test('check bluetooth initial state', function() {
+    assert.ok(
+      !bluetoothPanel.isBluetoothEnabled,
+      'bluetooth is disabled by default'
+    );
+  });
+
+  test('enable bluetooth', function() {
+    bluetoothPanel.enableBluetooth();
+    assert.ok(
+      bluetoothPanel.isBluetoothEnabled,
+      'bluetooth has been enabled'
+    );
+  });
+
+});

gaia/apps/settings/test/marionette/tests/browsing_privacy_settings_test.js

@@ -0,0 +1,91 @@
+'use strict';
+
+var Settings = require('../app/app'),
+    assert = require('assert');
+
+marionette('manipulate browsing privacy settings', function() {
+  var client = marionette.client({
+    desiredCapabilities: { raisesAccessibilityExceptions: false }
+  });
+  var settingsApp;
+  var browsingPrivacyPanel;
+
+  setup(function() {
+    settingsApp = new Settings(client);
+    settingsApp.launch();
+    // Navigate to the Browsing Privacy menu
+    browsingPrivacyPanel = settingsApp.browsingPrivacyPanel;
+  });
+
+  test('check private browsing initial state and toggle', function() {
+    assert.ok(
+      !browsingPrivacyPanel.isPrivateBrowsingEnabled,
+      'private browsing disabled by default'
+    );
+    browsingPrivacyPanel.enablePrivateBrowsing();
+    assert.ok(
+      browsingPrivacyPanel.isPrivateBrowsingEnabled,
+      'private browsing has been enabled'
+    );
+  });
+
+  test('check tracking protection initial state and toggle', function() {
+    assert.ok(
+      !browsingPrivacyPanel.isTrackingProtectionEnabled,
+      'tracking protection disabled by default'
+    );
+    browsingPrivacyPanel.enableTrackingProtection();
+    assert.ok(
+      browsingPrivacyPanel.isTrackingProtectionEnabled,
+      'tracking protection has been enabled'
+    );
+  });
+
+  test('check clear history button, confirm dialog will show' +
+       'click cancel, and click submit', function() {
+    browsingPrivacyPanel.clickClearHistoryButton();
+    assert.ok(
+      browsingPrivacyPanel.confirmDialogShown,
+      'confirm dialog is shown'
+    );
+    browsingPrivacyPanel.clickConfirmDialogCancel();
+    assert.ok(
+      !browsingPrivacyPanel.confirmDialogShown,
+      'confirm dialog is hidden'
+    );
+    browsingPrivacyPanel.clickClearHistoryButton();
+    assert.ok(
+      browsingPrivacyPanel.confirmDialogShown,
+      'confirm dialog is shown'
+    );
+    browsingPrivacyPanel.clickConfirmDialogSubmit();
+    assert.ok(
+      !browsingPrivacyPanel.confirmDialogShown,
+      'confirm dialog is hidden'
+    );
+  });
+
+  test('check private data button, confirm dialog will show' +
+       'click cancel, and click submit', function() {
+    browsingPrivacyPanel.clickClearPrivateDataButton();
+    assert.ok(
+      browsingPrivacyPanel.confirmDialogShown,
+      'confirm dialog is shown'
+    );
+    browsingPrivacyPanel.clickConfirmDialogCancel();
+    assert.ok(
+      !browsingPrivacyPanel.confirmDialogShown,
+      'confirm dialog is hidden'
+    );
+    browsingPrivacyPanel.clickClearPrivateDataButton();
+    assert.ok(
+      browsingPrivacyPanel.confirmDialogShown,
+      'confirm dialog is shown'
+    );
+    browsingPrivacyPanel.clickConfirmDialogSubmit();
+    assert.ok(
+      !browsingPrivacyPanel.confirmDialogShown,
+      'confirm dialog is hidden'
+    );
+  });
+});

gaia/apps/settings/test/marionette/tests/date_time_settings_test.js

@@ -0,0 +1,21 @@
+'use strict';
+var Settings = require('../app/app');
+
+marionette('manipulate date time settings', function() {
+  var client = marionette.client();
+  var settingsApp;
+  var dateTimePanel;
+
+  setup(function() {
+    settingsApp = new Settings(client);
+    settingsApp.launch();
+    dateTimePanel = settingsApp.dateTimePanel;
+  });
+
+  test('manipulate time format', function() {
+    // Simply select the value in the time format to
+    // ensure the menu is is populated.
+    dateTimePanel.selectTimeFormat('12-hour');
+  });
+
+});

gaia/apps/settings/test/marionette/tests/device_information_settings_test.js

@@ -0,0 +1,60 @@
+'use strict';
+var Settings = require('../app/app'),
+  assert = require('assert');
+
+marionette('check device information settings', function() {
+  var client = marionette.client({
+    profile: {
+      settings: {
+        'developer.menu.enabled': false
+      }
+    },
+    desiredCapabilities: { raisesAccessibilityExceptions: false }
+  });
+  var settingsApp;
+  var deviceInfoPanel, developerPanel;
+
+  setup(function() {
+    settingsApp = new Settings(client);
+    settingsApp.launch();
+    deviceInfoPanel = settingsApp.aboutPanel;
+  });
+
+  test('check more info panel', function() {
+    deviceInfoPanel.tapOnMoreInfoButton();
+    assert.equal(false, deviceInfoPanel.isDevelopMenuEnabled);
+    deviceInfoPanel.triggerDevelopMenu();
+    assert.equal(true, deviceInfoPanel.isDevelopMenuEnabled);
+    deviceInfoPanel.tapMoreInfoBackBtn();
+    deviceInfoPanel.tapDeviceInfoBackBtn();
+    assert.equal(true, deviceInfoPanel.isDeveloperMenuItemVisible);
+    developerPanel = settingsApp.developerPanel;
+  });
+
+  test('check your rights panel', function() {
+    deviceInfoPanel.tapOnYourRightsButton();
+  });
+
+  test('check your privacy panel', function() {
+    deviceInfoPanel.tapOnYourPrivacyButton();
+    deviceInfoPanel.tapOnPrivacyBrowserButton();
+  });
+
+  test('check legal information panel', function() {
+    deviceInfoPanel.tapOnLegalInfoButton();
+    deviceInfoPanel.tapOnOpenSourceNoticesButton();
+    deviceInfoPanel.tapOpenSourceNoticesBackBtn();
+    deviceInfoPanel.tapOnObtainingSourceCodeButton();
+  });
+
+  test('check reset phone', function() {
+    assert.ok(!deviceInfoPanel.isResetPhoneDialogVisible,
+      'Reset phone dialog is hidden');
+    deviceInfoPanel.tapOnResetPhoneButton();
+    assert.ok(deviceInfoPanel.isResetPhoneDialogVisible,
+      'Reset phone dialog is visible');
+    deviceInfoPanel.tapOnCancelResetPhoneButton();
+    assert.ok(!deviceInfoPanel.isResetPhoneDialogVisible,
+      'Reset phone dialog is hidden');
+  });
+});

gaia/apps/settings/test/marionette/tests/display_settings_test.js

@@ -0,0 +1,143 @@
+'use strict';
+
+var Settings = require('../app/app'),
+    SystemApp = require('../app/system_app'),
+    assert = require('assert');
+
+marionette('manipulate display settings', function() {
+  var client = marionette.client({
+    desiredCapabilities: { raisesAccessibilityExceptions: false }
+  });
+  var settingsApp;
+  var systemApp;
+  var displayPanel;
+
+  setup(function() {
+    systemApp = new SystemApp(client);
+    settingsApp = new Settings(client);
+    settingsApp.launch();
+  });
+
+  suite('check visibility of auto-brightness-toggle', function() {
+    test('show the toggle when with light sensor', function() {
+      client.executeScript(function() {
+        var theWindow = window.wrappedJSObject;
+        theWindow.LazyLoader.getJSON = function(path) {
+          return Promise.resolve({ ambientLight: true });
+        };
+      });
+      // Navigate to the display menu
+      // We need to mock LazyLoader.getJSON function before switching to panel.
+      displayPanel = settingsApp.displayPanel;
+      assert.ok(displayPanel.isAutoBrightnessItemVisible);
+    });
+
+    test('hide the toggle when without light sensor', function() {
+      client.executeScript(function() {
+        var theWindow = window.wrappedJSObject;
+        theWindow.LazyLoader.getJSON = function(path) {
+          return Promise.resolve({ ambientLight: false });
+        };
+      });
+      // Navigate to the display menu
+      displayPanel = settingsApp.displayPanel;
+      assert.ok(!displayPanel.isAutoBrightnessItemVisible);
+    });
+  });
+
+  suite('adjust brightness automatically', function() {
+    setup(function() {
+      // Navigate to the display menu
+      displayPanel = settingsApp.displayPanel;
+    });
+
+    suite('lock orientation', function() {
+      test('check default value', function() {
+        assert.ok(
+          !displayPanel.isLockOrientationChecked,
+          'lock orientation is disabled by default'
+        );
+      });
+
+      test('tap toggle', function() {
+        displayPanel.tapLockOrientationCheckbox();
+        client.waitFor(function() {
+          return displayPanel.isLockOrientationChecked;
+        }.bind(this));
+
+        assert.ok(
+          displayPanel.isLockOrientationChecked,
+          'lock orientation is enabled'
+        );
+        assert.ok(
+          displayPanel.screenOrientationSetting,
+          'screen.orientation.lock is true'
+        );
+      });
+    });
+
+    suite('check brightness functionality', function() {
+      var defaultAutoBrightnessEnabled;
+
+      test('check default value', function() {
+        // get the auto brightness value from mozSettings
+        defaultAutoBrightnessEnabled =
+          displayPanel.autoBrightnessSetting || false;
+        assert.ok(
+          displayPanel.isAutoBrightnessChecked === defaultAutoBrightnessEnabled,
+          'default adjust automatically enabled: ' +
+            defaultAutoBrightnessEnabled
+        );
+      });
+
+      test('tap toggle', function() {
+        displayPanel.tapAutoBrightnessCheckbox();
+        client.waitFor(function() {
+          return displayPanel.isAutoBrightnessChecked;
+        }.bind(this));
+
+        assert.ok(
+          displayPanel.isAutoBrightnessChecked !== defaultAutoBrightnessEnabled,
+          'adjust automatically enabled: ' + !defaultAutoBrightnessEnabled
+        );
+        assert.ok(displayPanel.autoBrightnessSetting !==
+          defaultAutoBrightnessEnabled);
+
+        var expectedVisibility = !displayPanel.isAutoBrightnessChecked;
+        assert.ok(
+          displayPanel.isBrightnessManualItemVisible === expectedVisibility,
+          'manual brightness item visibility: ' + expectedVisibility
+        );
+      });
+    });
+
+    suite('screen timeout', function() {
+      // Skip the test as currently we are not able to tap on a select element.
+      // Please refer to bug 977522 for details.
+      test.skip('tap selector', function() {
+        displayPanel.tapScreenTimeoutSelector();
+        assert.ok(
+          systemApp.isValueSelectorVisible(),
+          'screen timeout selector shows up'
+        );
+      });
+
+      test('tap screen timeout option', function() {
+        displayPanel.tapScreenTimeoutSelectOption('1 minute');
+        assert.ok(displayPanel.screenTimeoutSetting === 60);
+
+        displayPanel.tapScreenTimeoutSelectOption('2 minutes');
+        assert.ok(displayPanel.screenTimeoutSetting === 120);
+
+        displayPanel.tapScreenTimeoutSelectOption('5 minutes');
+        assert.ok(displayPanel.screenTimeoutSetting === 300);
+
+        displayPanel.tapScreenTimeoutSelectOption('10 minutes');
+        assert.ok(displayPanel.screenTimeoutSetting === 600);
+
+        displayPanel.tapScreenTimeoutSelectOption('never');
+        assert.ok(displayPanel.screenTimeoutSetting === 0);
+      });
+    });
+  });
+});

gaia/apps/settings/test/marionette/tests/do_not_track_settings_test.js

@@ -0,0 +1,35 @@
+'use strict';
+
+var Settings = require('../app/app'),
+    assert = require('assert');
+
+marionette('manipulate do not track settings', function() {
+  var client = marionette.client({
+    desiredCapabilities: { raisesAccessibilityExceptions: false }
+  });
+  var settingsApp;
+  var doNotTrackPanel;
+
+  setup(function() {
+    settingsApp = new Settings(client);
+    settingsApp.launch();
+    // Navigate to the Do Not Track menu
+    doNotTrackPanel = settingsApp.doNotTrackPanel;
+  });
+
+  test('check do not track initial state', function() {
+    assert.ok(
+      !doNotTrackPanel.isDoNotTrackEnabled,
+      'do not track is disabled by default'
+    );
+  });
+
+  test('enable do not track', function() {
+    doNotTrackPanel.enableDoNotTrack();
+    assert.ok(
+      doNotTrackPanel.isDoNotTrackEnabled,
+      'do not track has been enabled'
+    );
+  });
+
+});

gaia/apps/settings/test/marionette/tests/hotspot_wifi_settings_test.js

@@ -0,0 +1,42 @@
+'use strict';
+var Settings = require('../app/app'),
+    assert = require('assert');
+
+marionette('manipulate hotspot wifi settings', function() {
+  var client = marionette.client({
+    desiredCapabilities: { raisesAccessibilityExceptions: false }
+  });
+  var settingsApp;
+  var hotspotPanel;
+  var hotspotSettingsPanel;
+
+  setup(function() {
+    settingsApp = new Settings(client);
+    settingsApp.launch();
+    // Navigate to the Hotspot Settings menu
+    hotspotPanel = settingsApp.hotspotPanel;
+    hotspotSettingsPanel = settingsApp.hotspotSettingsPanel;
+  });
+
+  test('resets settings for second load', function() {
+    var defaultSsid = hotspotSettingsPanel.ssid;
+
+    assert.ok(
+      defaultSsid,
+      'ssid is provided by default'
+    );
+
+    hotspotSettingsPanel.ssid = 'Updated SSID ' + Date.now();
+
+    hotspotSettingsPanel.back();
+
+    hotspotSettingsPanel = settingsApp.hotspotSettingsPanel;
+
+    assert.equal(
+      defaultSsid,
+      hotspotSettingsPanel.ssid,
+      'ssid is reset to setting'
+    );
+  });
+
+});

gaia/apps/settings/test/marionette/tests/ime_uninstallation_test.js

@@ -0,0 +1,61 @@
+'use strict';
+var Settings = require('../app/app');
+var assert = require('assert');
+
+marionette('Uninstall an ime app', function() {
+  var IME_TEST_APP_ORIGIN = 'app://imetestapp.gaiamobile.org';
+  var IME_TEST_APP_NAME = 'LOL Keyboard';
+
+  var preloadApps = {};
+  // And a testing 3rd-party IME app
+  preloadApps[IME_TEST_APP_ORIGIN] = __dirname + '/../../fixtures/imetestapp';
+
+  var client = marionette.client({
+    profile: {
+      apps: preloadApps
+    }
+  });
+
+  var confirmDialog;
+  var settingsApp;
+  var appPermissionPanel;
+  var system;
+
+  setup(function() {
+    system = client.loader.getAppClass('system');
+    system.waitForFullyLoaded();
+    confirmDialog = client.loader.getAppClass('system', 'confirm_dialog');
+    settingsApp = new Settings(client);
+
+    settingsApp.launch();
+    appPermissionPanel = settingsApp.appPermissionPanel;
+  });
+
+  test('Uninstall the preload IME Test App', function() {
+    function findImeTestApp(element) {
+      return IME_TEST_APP_NAME === element.text();
+    }
+
+    // Find the IME Test app we preload.
+    var apps = appPermissionPanel.appList.filter(findImeTestApp);
+
+    // Make sure LOL Keyboard is listed.
+    assert.equal(apps.length, 1);
+
+    var imeAppItem = apps[0];
+    imeAppItem.click();
+    imeAppItem.tap(5, 5);
+    appPermissionPanel.uninstallButton.click();
+
+    // confirm to uninstall
+    client.switchToFrame();
+    confirmDialog.confirm('remove');
+
+    // Switch back to settings app
+    settingsApp.switchTo();
+
+    // Make sure LOL Keyboard is not listed in app list
+    apps = appPermissionPanel.appList.filter(findImeTestApp);
+    assert.equal(apps.length, 0);
+  });
+});

gaia/apps/settings/test/marionette/tests/improve_settings_test.js

@@ -0,0 +1,103 @@
+'use strict';
+var Settings = require('../app/app'),
+    assert = require('assert');
+
+marionette('improve b2g', function() {
+  var client = marionette.client({
+    desiredCapabilities: { raisesAccessibilityExceptions: false }
+  });
+  var settingsApp;
+  var improvePanel;
+  var feedbackPanel;
+  setup(function() {
+    settingsApp = new Settings(client);
+    settingsApp.launch();
+    // Navigate to the Improve panel
+    improvePanel = settingsApp.improvePanel;
+  });
+
+  suite('improve page', function() {
+
+    test('enable always send report', function() {
+      // make sure the item displaying on the screen
+      improvePanel.enableAskEachTime();
+      improvePanel.enableAlwaysSendReport();
+      assert.ok(true,
+        'always send report is enabled');
+    });
+
+    test('enable never send report', function() {
+      improvePanel.enableNeverSendReport();
+      assert.ok(true,
+        'never send report is enabled');
+    });
+
+    test('enable ask each time', function() {
+      improvePanel.enableAskEachTime();
+      assert.ok(true,
+        'ask each time is enabled');
+    });
+  });
+
+  suite('choose feedback page', function() {
+    setup(function() {
+      // Navigate to the feedback panel
+      feedbackPanel = settingsApp.feedbackPanel;
+      improvePanel.enterFeedbackPanel();
+      feedbackPanel.isRendered();
+    });
+
+    test('entering into send feedback panel and happy', function() {
+      feedbackPanel.enterWithHappy();
+      assert.ok(true,
+        '|happy| feedback entry is ok');
+    });
+
+    test('entering into send feedback panel and sad', function() {
+      feedbackPanel.enterWithSad();
+      assert.ok(true,
+        '|sad| feedback entry is ok');
+    });
+  });
+
+  suite('send feedback page', function() {
+    var feedbackPanel;
+    setup(function() {
+      feedbackPanel = settingsApp.feedbackPanel;
+      improvePanel.enterFeedbackPanel();
+      feedbackPanel.isRendered();
+      feedbackPanel.enterWithHappy();
+    });
+
+    test('empty message', function() {
+      feedbackPanel.sendFeedback();
+      assert.equal(feedbackPanel.alertMsg,
+        'Sorry, the system can’t send your suggestion ' +
+        'because the comment field is empty. Please enter ' +
+        'some text and try again.'
+        );
+    });
+
+    // disabled at bug #981993 because of intermittent failures
+    test.skip('open email column but left it empty', function() {
+      feedbackPanel.inputMsgToDialog('test');
+      feedbackPanel.openEmailCol();
+      feedbackPanel.sendFeedback();
+      assert.equal(feedbackPanel.alertMsg,
+        'Sorry, the system can’t send your suggestion ' +
+        'because the email address is missing or due to ' +
+        'a formatting error. Please use a valid email address ' +
+        'and try again.');
+    });
+
+    // disabled at bug #981993 because of intermittent failures
+    test.skip('click back and enter again, the msg should be the same',
+      function() {
+      var msg = 'test';
+      feedbackPanel.inputMsgToDialog(msg);
+      feedbackPanel.tapFeedbackBack();
+      feedbackPanel.enterWithHappy();
+      assert.equal(feedbackPanel.discription, msg);
+    });
+  });
+});

gaia/apps/settings/test/marionette/tests/keyboard_settings_test.js

@@ -0,0 +1,108 @@
+'use strict';
+var Settings = require('../app/app');
+var SettingsKeyboardApp = require('../app/keyboard_app');
+var KeyboardTestApp = require(
+  '../../../../keyboard/test/marionette/lib/keyboard_test_app');
+var KeyboardApp = require('../../../../keyboard/test/marionette/lib/keyboard');
+var assert = require('assert');
+
+marionette('manipulate keyboard settings', function() {
+  var client;
+  var settingsApp;
+  var settingsKeyboardApp;
+  var keyboardTestApp;
+  var keyboardApp;
+  var keyboardPanel;
+  var systemInputMgmt;
+  var apps = {};
+
+  apps[KeyboardTestApp.ORIGIN] =
+    __dirname + '/../../../../keyboard/test/marionette/apps/keyboardtestapp';
+  client = marionette.client({
+    profile: {
+      apps: apps,
+      prefs: {
+        'focusmanager.testmode': true
+      },
+      settings: {
+        'lockscreen.enabled': false,
+        'ftu.manifestURL': null
+      }
+    },
+    desiredCapabilities: { raisesAccessibilityExceptions: false }
+  });
+
+  setup(function() {
+    settingsKeyboardApp = new SettingsKeyboardApp(client);
+    settingsApp = new Settings(client);
+    keyboardApp = new KeyboardApp(client);
+    keyboardTestApp = new KeyboardTestApp(client);
+
+    settingsApp.launch();
+    // Navigate to the keyboard menu
+    keyboardPanel = settingsApp.keyboardPanel;
+  });
+
+  test('Launch built-in keyboard\'s settings page', function() {
+    keyboardPanel.tapBuiltInKeyboardItem();
+
+    settingsKeyboardApp.switchToSettings();
+
+    // Uncheck the vibration menu item and ensure mozSetting is set.
+    settingsKeyboardApp.clickVibrationOption();
+    assert.equal(settingsKeyboardApp.vibrationFromMozSettings, false);
+
+    settingsKeyboardApp.goBackToSettingsApp();
+
+    // switch back to settings frame and verify
+    settingsApp.switchTo();
+    assert.equal(keyboardPanel.header.getAttribute('action'), 'back');
+
+    // Check the icon is not shown as [X], which is for dialog style.
+    assert.ok(!keyboardPanel.isDialog());
+  });
+
+  test('Change keyboard language', function() {
+    // Keyboard location of special character ñ
+    var specialKeySelector = 'button[data-keycode-upper="209"]';
+
+    // Tap 'Select Keyboards' button
+    keyboardPanel.tapSelectKeyboards();
+
+    // Select keyboard language, then click back to make it "stick"
+    keyboardPanel.selectLayout('Espa\u00F1ol');
+    keyboardPanel.tapBackButton();
+    settingsApp.close();
+
+    // Launch the keyboard test app to verify the keyboard layout
+    keyboardTestApp.launch();
+    keyboardTestApp.textInput.tap();
+
+    // Switch to keyboard frame
+    systemInputMgmt = client.loader.getAppClass('system', 'input_management');
+    systemInputMgmt.waitForKeyboardFrameDisplayed();
+    systemInputMgmt.switchToActiveKeyboardFrame();
+
+    // Switch language, and check if keyboard language is indeed 'Es'
+    // Need to wait for the change before making an assertion.
+    keyboardApp.imeSwitchingKey.tap();
+    client.waitFor(function() {
+      return (keyboardApp.imeSwitchingKey.getAttribute('aria-label') === 'Es');
+    });
+    assert.equal(keyboardApp.imeSwitchingKey.getAttribute('aria-label'), 'Es');
+
+    // Try typing the special character
+    // The keyboardApp.type() method uses long-press, which is not normal user
+    // behaviour, and English keyboard would also be able to type it out.
+    client.waitFor(function() {
+      return client.findElement(specialKeySelector).displayed();
+    });
+    client.findElement(specialKeySelector).tap();
+
+    // Verify the typed key is correct
+    client.switchToFrame();
+    keyboardTestApp.launch();
+    assert.equal(keyboardTestApp.textInput.getAttribute('value'), '\u00F1',
+      '\u00F1 is typed out');
+  });
+});

gaia/apps/settings/test/marionette/tests/language_settings_test.js

@@ -0,0 +1,142 @@
+'use strict';
+
+/* global Event */
+
+var Settings = require('../app/app'),
+    assert = require('assert');
+
+marionette('manipulate language settings', function() {
+  var client = marionette.client();
+  var settingsApp;
+
+  setup(function() {
+    settingsApp = new Settings(client);
+    settingsApp.launch();
+  });
+
+  suite('change language', function() {
+    var languagePanel;
+
+    setup(function() {
+      client.settings.set('devtools.pseudolocalization.enabled', true);
+      languagePanel = settingsApp.languagePanel;
+      languagePanel.setupDefaultLanguage();
+    });
+
+    teardown(function() {
+      client.settings.set('devtools.pseudolocalization.enabled', false);
+    });
+
+    test('label in the panel is translated.', function() {
+      languagePanel.currentLanguage = 'accented';
+      assert.equal(languagePanel.currentLanguage, 'accented');
+
+      languagePanel.currentLanguage = 'bidi';
+      assert.equal(languagePanel.currentLanguage, 'bidi');
+
+      languagePanel.currentLanguage = 'english';
+      assert.equal(languagePanel.currentLanguage, 'english');
+    });
+
+    test('mozSettings value is correct', function() {
+      languagePanel.currentLanguage = 'accented';
+      assert.equal(languagePanel.currentLanguageFromMozSettings,
+                   'fr-x-psaccent');
+
+      languagePanel.currentLanguage = 'bidi';
+      assert.equal(languagePanel.currentLanguageFromMozSettings,
+                   'ar-x-psbidi');
+
+      languagePanel.currentLanguage = 'english';
+      assert.equal(languagePanel.currentLanguageFromMozSettings,
+                   'en-US');
+    });
+
+    test('sample format is translated', function() {
+      languagePanel.currentLanguage = 'accented';
+      assert.ok(languagePanel.isSampleFormatTranslated('accented'));
+
+      languagePanel.currentLanguage = 'bidi';
+      assert.ok(languagePanel.isSampleFormatTranslated('bidi'));
+
+      languagePanel.currentLanguage = 'english';
+      assert.ok(languagePanel.isSampleFormatTranslated('english'));
+    });
+  });
+
+  suite('pseudolanguages', function() {
+    var languagePanel;
+    var quickly;
+
+    setup(function() {
+      // this allows waitForElement* methods to fail quickly
+      quickly = client.scope({ searchTimeout: 50 });
+      quickly.helper.client = quickly;
+
+      languagePanel = settingsApp.languagePanel;
+      languagePanel.setupDefaultLanguage();
+      languagePanel.back();
+    });
+
+    test('the setting is off', function() {
+      quickly.settings.set('devtools.pseudolocalization.enabled', false);
+      languagePanel = settingsApp.languagePanel;
+
+      quickly.helper.waitForElement('option[value="en-US"]');
+      quickly.helper.waitForElementToDisappear('option[value="fr-x-psaccent"]');
+      assert.ok(true, 'fr-x-psaccent is not listed');
+    });
+
+    test('turning the setting on and off', function() {
+      // 1. turn the setting on
+      quickly.settings.set('devtools.pseudolocalization.enabled', true);
+      languagePanel = settingsApp.languagePanel;
+
+      quickly.helper.waitForElement('option[value="fr-x-psaccent"]');
+      assert.ok(true, 'fr-x-psaccent is listed');
+      quickly.helper.waitForElement('option[value="ar-x-psbidi"]');
+      assert.ok(true, 'ar-x-psbidi is listed');
+
+      languagePanel.currentLanguage = 'accented';
+      languagePanel.back();
+
+      // 2. turn the setting off
+      quickly.settings.set('devtools.pseudolocalization.enabled', false);
+
+      languagePanel = settingsApp.languagePanel;
+      quickly.helper.waitForElement('option[value="fr-x-psaccent"]');
+      assert.ok(true, 'fr-x-psaccent is listed');
+      quickly.helper.waitForElementToDisappear('option[value="ar-x-psbidi"]');
+      assert.ok(true, 'ar-x-psbidi is not listed');
+
+      languagePanel.currentLanguage = 'english';
+
+      // 3. when a new language is chosen, pseudolocales are removed
+      //    from the select dropdown
+
+      // XXX For this test we need to emulate a blur event which is
+      // normally emitted when the user confirms the choice of the
+      // language.  In Marionette, the event is not dispatched.  See
+      // bug: https://bugzil.la/1050206
+      var selectEl = languagePanel.findElement('languageChangeSelect');
+      selectEl.scriptWith(function(selectEl) {
+        var evt = new Event('blur', {
+          'view': window,
+          'bubbles': true,
+          'cancelable': true
+        });
+        selectEl.dispatchEvent(evt);
+      });
+
+      quickly.helper.waitForElementToDisappear('option[value="fr-x-psaccent"]');
+      assert.ok(true, 'fr-x-psaccent is not listed');
+
+      languagePanel.back();
+
+      // 4. reopen the panel
+      languagePanel = settingsApp.languagePanel;
+      quickly.helper.waitForElementToDisappear('option[value="fr-x-psaccent"]');
+      assert.ok(true, 'fr-x-psaccent is not listed');
+    });
+  });
+});

gaia/apps/settings/test/marionette/tests/manifest.ini

@@ -0,0 +1,19 @@
+[sound_settings_test.js]
+[language_settings_test.js]
+[root_settings_test.js]
+[bluetooth_settings_test.js]
+[hotspot_wifi_settings_test.js]
+[keyboard_settings_test.js]
+[app_permission_settings_test.js]
+[battery_settings_test.js]
+[support_settings_test.js]
+[media_storage_settings_test.js]
+[notifications_settings_test.js]
+[do_not_track_settings_test.js]
+[improve_settings_test.js]
+[display_settings_test.js]
+[app_storage_settings_test.js]
+[message_settings_test.js]
+[airplane_mode_settings_test.js]
+[ime_uninstallation_test.js]
+[screen_lock_settings_test.js]

gaia/apps/settings/test/marionette/tests/media_storage_settings_test.js

@@ -0,0 +1,51 @@
+'use strict';
+var Settings = require('../app/app'),
+    assert = require('assert');
+
+marionette('manipulate media storage settings', function() {
+  var client = marionette.client();
+  var settingsApp;
+  var mediaStoragePanel;
+
+  setup(function() {
+    settingsApp = new Settings(client);
+    settingsApp.launch();
+    // Navigate to the Media storage menu
+    mediaStoragePanel = settingsApp.mediaStoragePanel;
+  });
+
+  suite('check media storage basics', function() {
+    test.skip('check storage data contain numbers', function() {
+      assert.ok(mediaStoragePanel.containNumberInMusicSpace);
+      assert.ok(mediaStoragePanel.containNumberInPictureSpace);
+      assert.ok(mediaStoragePanel.containNumberInVideoSpace);
+    });
+
+    test.skip('check free/total space contain numbers', function() {
+      assert.ok(mediaStoragePanel.containNumberInFreeSpace);
+      assert.ok(mediaStoragePanel.containNumberInTotalSpace);
+    });
+
+    // Since 'canBeFormatted' attribute is false on b2g desktop,
+    // there is no foramt button for the functionality.
+    // So we have to skip over the test case.
+    // Once bug 1055992 fixed, we can re-enable the test case.
+    test.skip('tap on Format SD card button', function() {
+      mediaStoragePanel.tapOnFormatSdcardButton();
+      assert.ok(
+        mediaStoragePanel.isFormatSdcardDialogShowed,
+        'will show dialog'
+      );
+    });
+
+  });
+
+  suite('check media storage advanced', function() {
+    test('check initial state', function() {
+      assert.ok(
+        !mediaStoragePanel.isMediaLocationSelectorEnabled,
+        'Media location selector is disabled by default'
+      );
+    });
+  });
+});

gaia/apps/settings/test/marionette/tests/message_settings_test.js

@@ -0,0 +1,71 @@
+'use strict';
+
+var Settings = require('../app/app');
+var assert = require('assert');
+
+marionette('message settings', function() {
+  var client = marionette.client({
+    desiredCapabilities: { raisesAccessibilityExceptions: false }
+  });
+  var settingsApp;
+  var messagePanel;
+
+  setup(function() {
+    settingsApp = new Settings(client);
+    settingsApp.launch();
+    messagePanel = settingsApp.messagePanel;
+  });
+
+  suite('click on all menuItems', function() {
+    setup(function() {
+      messagePanel.initialMessagingSettings();
+      messagePanel.toggleMenuItem('deliveryReport', true);
+      messagePanel.toggleMenuItem('readReport', true);
+      messagePanel.toggleMenuItem('wapPush', true);
+      messagePanel.toggleMenuItem('cellBroadcast', true);
+      messagePanel.toggleMenuItem('emergencyAlert', true);
+
+      // select specific option
+      messagePanel.chooseRetrieveMethod('On with roaming');
+    });
+
+    test('we would reflect status on related stuffs', function() {
+      assert.equal(messagePanel.isChecked('deliveryReportCheckbox'), true);
+      assert.equal(messagePanel.isChecked('readReportCheckbox'), true);
+      assert.equal(messagePanel.isChecked('wapPushCheckbox'), true);
+      assert.equal(messagePanel.isComponentChecked('cellBroadcastCheckbox'),
+        true);
+      assert.equal(messagePanel.isComponentChecked('emergencyAlertCheckbox'),
+        true);
+      assert.equal(
+        client.settings.get('ril.sms.requestStatusReport.enabled'), true);
+      assert.equal(
+        client.settings.get('ril.mms.requestReadReport.enabled'), true);
+      assert.equal(
+        client.settings.get('wap.push.enabled'), true);
+      assert.equal(
+        client.settings.get('ril.cellbroadcast.disabled'), false);
+      assert.equal(
+        client.settings.get('cmas.enabled')[0], true);
+
+      // we will keep its value as `automatic`
+      assert.equal(messagePanel.getSelectedRetrieveMethod(), 'automatic');
+    });
+  });
+
+  suite('check Cell Broadcast and CMAS dependency', function() {
+    setup(function() {
+      messagePanel.initialMessagingSettings();
+      messagePanel.toggleMenuItem('emergencyAlert', true);
+      messagePanel.toggleMenuItem('cellBroadcast', false);
+    });
+
+    test('when CB off, CMAS is also off and disabled', function() {
+      assert.equal(
+        client.settings.get('ril.cellbroadcast.disabled'), true);
+      assert.equal(
+        client.settings.get('cmas.enabled')[0], false);
+      assert.equal(messagePanel.isEmergencyAlertCheckboxEnabled, false);
+    });
+  });
+});

gaia/apps/settings/test/marionette/tests/notifications_settings_test.js

@@ -0,0 +1,34 @@
+'use strict';
+var Settings = require('../app/app'),
+    assert = require('assert');
+
+marionette('manipulate notifications settings', function() {
+  var client = marionette.client({
+    desiredCapabilities: { raisesAccessibilityExceptions: false }
+  });
+  var settingsApp;
+  var notificationsPanel;
+
+  setup(function() {
+    settingsApp = new Settings(client);
+    settingsApp.launch();
+    // Navigate to the battery menu
+    notificationsPanel = settingsApp.notificationsPanel;
+  });
+
+  test('check Show on lockscreen checkbox initial state', function() {
+    assert.ok(
+      notificationsPanel.isShowOnLockScreenEnabled,
+      'Show on lockscreen is disabled by default'
+    );
+  });
+
+  test('disable Show on lockscreen', function() {
+    notificationsPanel.tapOnShowOnLockScreen();
+    assert.ok(
+      !notificationsPanel.isShowOnLockScreenEnabled,
+      'Show on lockscreen has been disabled'
+    );
+  });
+
+});

gaia/apps/settings/test/marionette/tests/root_settings_test.js

@@ -0,0 +1,155 @@
+'use strict';
+var Settings = require('../app/app'),
+    assert = require('assert');
+
+marionette('check root panel settings', function() {
+  var client = marionette.client({
+    desiredCapabilities: { raisesAccessibilityExceptions: false }
+  });
+  var settingsApp;
+  var rootPanel;
+
+  var hasNumbers = function(t) {
+    return /\d/.test(t);
+  };
+
+  setup(function() {
+    settingsApp = new Settings(client);
+  });
+
+  // Common tests are the tests that use the basic hardware configuration.
+  suite('common tests', function() {
+    setup(function() {
+      // We need to inject the script before launching settings app because it
+      // access to the objects upon starting up.
+      client.contentScript.inject(__dirname +
+        '/../mocks/mock_navigator_moz_wifi_manager.js');
+      client.contentScript.inject(__dirname +
+        '/../mocks/mock_navigator_moz_bluetooth.js');
+
+      client.settings.set('devtools.pseudolocalization.enabled', true);
+
+      settingsApp.launch();
+      rootPanel = settingsApp.rootPanel;
+    });
+
+    teardown(function() {
+      client.settings.set('devtools.pseudolocalization.enabled', false);
+    });
+
+    test('check static item descriptions', function() {
+      // The content of the root panel are delay loaded. We need to wait for
+      // the actual result.
+      client.waitFor(function() {
+        return rootPanel.bluetoothDesc === 'Turned off';
+      });
+      // client.waitFor(function() {
+      //   return rootPanel.firefoxAccountDesc === 'Create Account or Sign In';
+      // });
+      client.waitFor(function() {
+        return rootPanel.screenLockDesc === 'Disabled';
+      });
+      // client.waitFor(function() {
+      //   return rootPanel.WiFiDesc === 'Not connected';
+      // });
+      client.waitFor(function() {
+        return hasNumbers(rootPanel.applicationStorageDesc);
+      });
+      client.waitFor(function() {
+        return hasNumbers(rootPanel.batteryDesc);
+      });
+      // client.waitFor(function() {
+      //   return hasNumbers(rootPanel.mediaStorageDesc);
+      // });
+    });
+
+    test('language description on the root panel is translated',
+      function() {
+      settingsApp.currentLanguage = 'accented';
+      assert.ok(
+        rootPanel.isLanguageDescTranslated('accented'),
+        'language desc was not localized into Accented English');
+
+      settingsApp.currentLanguage = 'bidi';
+      assert.ok(
+        rootPanel.isLanguageDescTranslated('bidi'),
+        'language desc was not localized into Bidi English');
+
+      settingsApp.currentLanguage = 'english';
+      assert.ok(
+        rootPanel.isLanguageDescTranslated('english'),
+        'language desc was not localized into English');
+    });
+
+    suite('airplane mode', function() {
+      test('check default value', function() {
+        assert.ok(!rootPanel.airplaneModeCheckboxChecked,
+          'airplane mode should be disabled by default');
+      });
+
+      // test('enable airplane mode', function() {
+      //   rootPanel.airplaneMode(true);
+      //   assert.ok(rootPanel.airplaneModeCheckboxChecked,
+      //     'airplane mode should be enabled');
+      // });
+    });
+
+    suite('geolocation', function() {
+      test('check default value', function() {
+        assert.ok(rootPanel.geolocationCheckboxChecked,
+          'geolocation should be enabled by default');
+      });
+
+      // test('disable geolocation', function() {
+      //   rootPanel.geolocation(false);
+      //   assert.ok(!rootPanel.geolocationCheckboxChecked,
+      //     'geolocation should be disabled');
+      //   assert.ok(!rootPanel.geolocationEnabledSetting,
+      //     'geolocation.enabled should be false');
+      // });
+    });
+  });
+
+  suite('sim related tests', function() {
+    suite('single sim tests', function() {
+      setup(function() {
+        client.contentScript.inject(__dirname +
+          '/../mocks/mock_navigator_moz_mobile_connections.js');
+        client.contentScript.inject(__dirname +
+          '/../mocks/mock_navigator_moz_telephony.js');
+
+        settingsApp.launch();
+        rootPanel = settingsApp.rootPanel;
+      });
+
+      test('ensure sim security item visible', function() {
+        assert.ok(rootPanel.isSimSecurityItemVisible);
+      });
+
+      test('ensure sim manager item invisible', function() {
+        assert.ok(!rootPanel.isSimManagerItemVisible);
+      });
+    });
+
+    suite('multiple sim tests', function() {
+      setup(function() {
+        client.contentScript.inject(__dirname +
+          '/../mocks/mock_navigator_moz_mobile_connections_multi.js');
+        client.contentScript.inject(__dirname +
+          '/../mocks/mock_navigator_moz_telephony.js');
+
+        settingsApp.launch();
+        rootPanel = settingsApp.rootPanel;
+      });
+
+      test('ensure sim security item visible', function() {
+        assert.ok(!rootPanel.isSimSecurityItemVisible);
+      });
+
+      test('ensure sim manager item invisible', function() {
+        assert.ok(rootPanel.isSimManagerItemVisible);
+      });
+    });
+  });
+
+});

gaia/apps/settings/test/marionette/tests/screen_lock_settings_test.js

@@ -0,0 +1,274 @@
+'use strict';
+var Settings = require('../app/app'),
+    LockScreen = require('../../../../system/test/marionette/lib/lockscreen'),
+    LockScreenPasscodeUnlockActions = require(
+      '../../../../system/test/marionette/lib/' +
+      'lockscreen_passcode_unlock_actions'),
+    Promise = require('es6-promise').Promise, // jshint ignore:line
+    assert = require('assert');
+
+marionette('manipulate screenLock settings', function() {
+  var client = marionette.client({
+    desiredCapabilities: { raisesAccessibilityExceptions: false }
+  });
+  var settingsApp;
+  var screenLockPanel;
+  var lockScreen;
+  var actions;
+
+  setup(function() {
+    lockScreen = (new LockScreen()).start(client);
+    settingsApp = new Settings(client);
+    settingsApp.launch();
+    // Navigate to the ScreenLock menu
+    screenLockPanel = settingsApp.screenLockPanel;
+    screenLockPanel.setupScreenLock();
+  });
+
+  test('lockscreen is enabled', function() {
+    screenLockPanel.toggleScreenLock();
+
+    assert.ok(screenLockPanel.isScreenLockEnabled(),
+      'screenlock is enabled');
+    assert.ok(screenLockPanel.isScreenLockChecked(),
+      'screenlock is checked');
+  });
+
+  test('passcode can\'t be enabled when passcode is wrong', function() {
+    screenLockPanel.toggleScreenLock();
+    screenLockPanel.togglePasscodeLock();
+    screenLockPanel.typePasscode('1234', '5678');
+
+    assert.ok(screenLockPanel.isPasscodeNotMatched());
+    assert.ok(!screenLockPanel.isPasscodeLockEnabled(),
+      'passcode is not enabled');
+    assert.ok(!screenLockPanel.isPasscodeChecked(),
+      'passcode is not checked');
+  });
+
+  // Disabled for intermittent failures. Bug 983171
+  test.skip(
+    'passcode is enabled, and we want to disable passcode ' +
+    'but failed to enter the right code',
+    function() {
+      var oldCode = '1234';
+      var newCode = '4567';
+      screenLockPanel.toggleScreenLock();
+      screenLockPanel.togglePasscodeLock();
+      screenLockPanel.typePasscode(oldCode, oldCode);
+      screenLockPanel.tapCreatePasscode();
+
+      assert.ok(screenLockPanel.isPasscodeLockEnabled(),
+        'passcode is enabled');
+      assert.ok(screenLockPanel.isPasscodeChecked(),
+        'passcode is checked');
+
+      screenLockPanel.togglePasscodeLock();
+      screenLockPanel.typePasscode(newCode);
+
+      assert.ok(screenLockPanel.isPasscodeIncorrect(),
+        'passcode is not correct');
+      assert.ok(screenLockPanel.isPasscodeLockEnabled(),
+        'passcode is still enabled');
+      assert.ok(screenLockPanel.isPasscodeChecked(),
+        'passcode is still checked');
+  });
+
+  // Disabled for intermittent failures. Bug 983171
+  test.skip('passcode is enabled, and get disabled successfully', function() {
+    var rightCode = '1234';
+    screenLockPanel.toggleScreenLock();
+    screenLockPanel.togglePasscodeLock();
+    screenLockPanel.typePasscode(rightCode, rightCode);
+    screenLockPanel.tapCreatePasscode();
+
+    assert.ok(screenLockPanel.isPasscodeLockEnabled(),
+      'passcode is enabled');
+    assert.ok(screenLockPanel.isPasscodeChecked(),
+      'passcode is checked');
+
+
+    screenLockPanel.togglePasscodeLock();
+    screenLockPanel.typePasscode(rightCode);
+
+    assert.ok(!screenLockPanel.isPasscodeLockEnabled(),
+      'passcode is disabled');
+    assert.ok(!screenLockPanel.isPasscodeChecked(),
+      'passcode is not checked');
+  });
+
+  test.skip(
+    'passcode is enabled and won\'t get disabled if you tap back button ' +
+    'when we try to disable passcode directly',
+    function() {
+      var code = '1234';
+      screenLockPanel.toggleScreenLock();
+      screenLockPanel.togglePasscodeLock();
+      screenLockPanel.typePasscode(code, code);
+      screenLockPanel.tapCreatePasscode();
+
+      screenLockPanel.togglePasscodeLock();
+      screenLockPanel.tapBackButton();
+
+      assert.ok(screenLockPanel.isPasscodeLockEnabled(),
+        'passcode is still enabled');
+      assert.ok(screenLockPanel.isPasscodeChecked(),
+        'passcode is still checked');
+  });
+
+  // Disabled for intermittent failures. Bug 983171
+  test.skip(
+    'passcode is enabled and won\'t get disabled if you tap back button ' +
+    'when we try to disable screenlock directly',
+    function() {
+      var code = '1234';
+      screenLockPanel.toggleScreenLock();
+      screenLockPanel.togglePasscodeLock();
+      screenLockPanel.typePasscode(code, code);
+      screenLockPanel.tapCreatePasscode();
+
+      screenLockPanel.toggleScreenLock();
+      screenLockPanel.tapBackButton();
+
+      assert.ok(screenLockPanel.isPasscodeLockEnabled(),
+        'passcode is still enabled');
+      assert.ok(screenLockPanel.isPasscodeChecked(),
+        'passcode is still checked');
+  });
+
+  // Disabled for intermittent failures. Bug 983171
+  test.skip(
+    'passcode is enabled and won\'t get disabled if you tap back button ' +
+    'when we try to edit passcode',
+    function() {
+      var code = '1234';
+      screenLockPanel.toggleScreenLock();
+      screenLockPanel.togglePasscodeLock();
+      screenLockPanel.typePasscode(code, code);
+      screenLockPanel.tapCreatePasscode();
+
+      screenLockPanel.tapEditPasscode();
+      screenLockPanel.tapBackButton();
+
+      assert.ok(screenLockPanel.isPasscodeLockEnabled(),
+        'passcode is still enabled');
+      assert.ok(screenLockPanel.isPasscodeChecked(),
+        'passcode is still checked');
+  });
+
+  test(
+    'passcode is enabled, and we want to edit passcode ' +
+    'but failed to enter the right code',
+    function() {
+      var oldCode = '0000';
+      var newCode = '4567';
+      screenLockPanel.toggleScreenLock();
+      screenLockPanel.togglePasscodeLock();
+      screenLockPanel.typePasscode(oldCode, oldCode);
+      screenLockPanel.tapCreatePasscode();
+
+      assert.ok(screenLockPanel.isPasscodeLockEnabled(),
+        'passcode is enabled');
+      assert.ok(screenLockPanel.isPasscodeChecked(),
+        'passcode is checked');
+
+
+      screenLockPanel.tapEditPasscode(newCode);
+
+      screenLockPanel.waitForElement('passcodeIncorrectLabel');
+      assert.ok(screenLockPanel.isPasscodeIncorrect(),
+        'passcode is not correct');
+      assert.ok(screenLockPanel.isPasscodeLockEnabled(),
+        'passcode is still enabled');
+      assert.ok(screenLockPanel.isPasscodeChecked(),
+        'passcode is still checked');
+  });
+
+  test('passcode is enabled, then get changed successfully', function() {
+    var oldCode = '1234';
+    var newCode = '4567';
+    screenLockPanel.toggleScreenLock();
+    screenLockPanel.togglePasscodeLock();
+    screenLockPanel.typePasscode(oldCode, oldCode);
+    screenLockPanel.tapCreatePasscode();
+
+    assert.ok(screenLockPanel.isPasscodeLockEnabled(),
+      'passcode is enabled');
+    assert.ok(screenLockPanel.isPasscodeChecked(),
+      'passcode is checked');
+
+    screenLockPanel.tapEditPasscode(oldCode);
+    screenLockPanel.typePasscode(newCode, newCode);
+    screenLockPanel.tapChangePasscode();
+  });
+
+  // Disabled for intermittent failures. Bug 983171
+  test.skip('passcode is enabled, and we want to disable lockscreen directly ' +
+    'but failed to enter the right code',
+    function() {
+      var rightCode = '1234';
+      var wrongCode = '5678';
+      screenLockPanel.toggleScreenLock();
+      screenLockPanel.togglePasscodeLock();
+      screenLockPanel.typePasscode(rightCode, rightCode);
+      screenLockPanel.tapCreatePasscode();
+
+      screenLockPanel.toggleScreenLock();
+      screenLockPanel.typePasscode(wrongCode);
+
+      assert.ok(screenLockPanel.isPasscodeIncorrect(),
+        'passcode is not correct');
+      assert.ok(screenLockPanel.isPasscodeLockEnabled(),
+        'passcode is still enabled');
+      assert.ok(screenLockPanel.isPasscodeChecked(),
+        'passcode is still checked');
+  });
+
+  // Disabled for intermittent failures. Bug 983171
+  test.skip('passcode is enabled, and we want to disable lockscreen directly',
+    function() {
+      var code = '1234';
+      screenLockPanel.toggleScreenLock();
+      screenLockPanel.togglePasscodeLock();
+      screenLockPanel.typePasscode(code, code);
+      screenLockPanel.tapCreatePasscode();
+
+      screenLockPanel.toggleScreenLock();
+      screenLockPanel.typePasscode(code);
+
+      assert.ok(!screenLockPanel.isScreenLockEnabled(),
+        'screenlock is not enabled');
+      assert.ok(!screenLockPanel.isScreenLockChecked(),
+        'screenlock is not checked');
+  });
+
+  test('passcode is enabled, and we want to lock and unlock the device',
+  function(done) {
+    var code = '1337';
+    screenLockPanel.toggleScreenLock();
+    screenLockPanel.togglePasscodeLock();
+    screenLockPanel.typePasscode(code, code);
+    screenLockPanel.tapCreatePasscode();
+    lockScreen.lock();
+
+    new Promise(function(resolve) {
+      actions = (new LockScreenPasscodeUnlockActions()).start(client);
+      return lockScreen.slideToUnlock(resolve);
+    })
+    .then(function() {
+      code.split('').forEach(function(keyChar) {
+        actions.pressKey(keyChar);
+      });
+    })
+    .then(function() {
+      return actions.waitForUnlock();
+    })
+    .then(function() {
+      settingsApp.switchTo();
+      assert.ok(screenLockPanel.isScreenLockHeaderLabelVisible(),
+        'has not returned to settings panel');
+    })
+    .then(done)
+    .catch(done);
+  });
+});

gaia/apps/settings/test/marionette/tests/sound_settings_test.js

@@ -0,0 +1,144 @@
+'use strict';
+var Settings = require('../app/app'),
+    assert = require('assert');
+
+marionette('manipulate sound settings', function() {
+  var client = marionette.client({
+    desiredCapabilities: { raisesAccessibilityExceptions: false }
+  });
+  var settingsApp;
+  var soundPanel;
+
+  setup(function() {
+    settingsApp = new Settings(client);
+
+    client.contentScript.inject(__dirname +
+      '/../mocks/mock_navigator_moz_telephony.js');
+
+    settingsApp.launch();
+    // Navigate to the sound menu
+    soundPanel = settingsApp.soundPanel;
+  });
+
+  test('check vibrate mode initial state', function() {
+    assert.ok(
+      soundPanel.isVibrateEnabled,
+      'vibrate mode is enabled by default'
+    );
+  });
+
+  test('disable vibrate mode', function() {
+    soundPanel.tapOnVibration();
+    assert.ok(
+      !soundPanel.isVibrateEnabled,
+      'vibrate mode has been disabled'
+    );
+  });
+
+  /* Volume */
+  test('change media state', function() {
+    var value = soundPanel.contentValue;
+    soundPanel.tapOnMediaSlider();
+    var content_val = (value === soundPanel.contentValue);
+    assert.ok(
+      !content_val,
+      'media state is changed'
+    );
+  });
+
+  test('change ringer state', function() {
+    var value = soundPanel.ringerValue;
+    soundPanel.tapOnRingerSlider();
+    var ringer_val = (value === soundPanel.ringerValue);
+    assert.ok(
+      !ringer_val,
+      'ringer state is changed'
+    );
+  });
+
+  test('change alarm state', function() {
+    var alarm_value = soundPanel.alarmValue;
+    soundPanel.tapOnAlarmSlider();
+    var alarm_val = (alarm_value === soundPanel.alarmValue);
+    assert.ok(
+      !alarm_val,
+      'alarm state is changed'
+    );
+  });
+
+  test('check default ringtone name', function() {
+    var ringtone_name = soundPanel.selectedRingtone;
+    // We can't do `===` because the string may be in RTL marks
+    assert.ok(ringtone_name.includes('Firefox') ||
+              ringtone_name.includes('Default'));
+  });
+
+  test('check default alert tone name', function() {
+    var alerttone_name = soundPanel.selectedAlertTone;
+    // We can't do `===` because the string may be in RTL marks
+    assert.ok(alerttone_name.includes('Firefox') ||
+              alerttone_name.includes('Default'));
+  });
+
+  /* Other sounds */
+  test('check keypad initial state', function() {
+    assert.ok(
+      soundPanel.isKeypadChecked,
+      'keypad sound is enabled by default'
+    );
+  });
+
+  test('disable keypad sound', function() {
+    soundPanel.tapOnKeypad();
+    assert.ok(
+      !soundPanel.isKeypadChecked,
+      'keypad sound has been disabled'
+    );
+  });
+
+  test('check camera initial state', function() {
+    assert.ok(
+      soundPanel.isCameraChecked,
+      'camera sound is enabled by default'
+    );
+  });
+
+  test('disable camera sound', function() {
+    soundPanel.tapOnCamera();
+    assert.ok(
+      !soundPanel.isCameraChecked,
+      'camera sound has been disabled'
+    );
+  });
+
+  test('check sent message initial state', function() {
+    assert.ok(
+      soundPanel.isSentMessageChecked,
+      'sent message sound is enabled by default'
+    );
+  });
+
+  test('disable sent message sound', function() {
+    soundPanel.tapOnSentMessage();
+    assert.ok(
+      !soundPanel.isSentMessageChecked,
+      'sent message sound has been disabled'
+    );
+  });
+
+  test('check unlock screen initial state', function() {
+    assert.ok(
+      !soundPanel.isUnlockScreenChecked,
+      'unlock screen sound is disabled by default'
+    );
+  });
+
+  test('enable unlock screen sound', function() {
+    soundPanel.tapOnUnlockScreen();
+    assert.ok(
+      soundPanel.isUnlockScreenChecked,
+      'unlock screen sound has been enabled'
+    );
+  });
+
+});

gaia/apps/settings/test/marionette/tests/support_settings_test.js

@@ -0,0 +1,124 @@
+'use strict';
+var Settings = require('../app/app'),
+    assert = require('assert');
+
+marionette('manipulate support settings', function() {
+  var client = marionette.client();
+  var settingsApp;
+  var supportPanel;
+
+  function gotoSupportPanel() {
+    settingsApp = new Settings(client);
+    settingsApp.launch();
+    // Navigate to the Support menu
+    supportPanel = settingsApp.supportPanel;
+  }
+
+  suite('check support without SIM custom', function() {
+
+    setup(function() {
+      gotoSupportPanel();
+    });
+
+    test('check support initial state', function() {
+      assert.ok(
+        !supportPanel.isOnlineSupportEnabled,
+        'online support is disabled by default'
+      );
+
+      assert.ok(
+        !supportPanel.isCallSupportEnabled,
+        'call support is disabled by default'
+      );
+    });
+
+  });
+
+//   suite('check support with SIM custom', function() {
+//     var onlineSupportTitleKey = 'support.onlinesupport.title';
+//     var onlineSupportTitleValue = 'Online support';
+//     var onlineSupportHrefKey = 'support.onlinesupport.href';
+//     var onlineSupportHrefValue = 'http://www.mozilla.org/';
+
+//     var callSupport1TitleKey = 'support.callsupport1.title';
+//     var callSupport1TitleValue = 'Call support 1';
+//     var callSupport1HrefKey = 'support.callsupport1.href';
+//     var callSupport1HrefValue = 'tel:666';
+
+//     var callSupport2TitleKey = 'support.callsupport2.title';
+//     var callSupport2TitleValue = 'Call support 2';
+//     var callSupport2HrefKey = 'support.callsupport2.href';
+//     var callSupport2HrefValue = 'tel:999';
+
+//     setup(function() {
+//       client.settings.set(onlineSupportTitleKey, onlineSupportTitleValue);
+//       client.settings.set(onlineSupportHrefKey, onlineSupportHrefValue);
+//       client.settings.set(callSupport1TitleKey, callSupport1TitleValue);
+//       client.settings.set(callSupport1HrefKey, callSupport1HrefValue);
+//       client.settings.set(callSupport2TitleKey, callSupport2TitleValue);
+//       client.settings.set(callSupport2HrefKey, callSupport2HrefValue);
+//       gotoSupportPanel();
+//     });
+
+//     test('check custom support state', function() {
+//       assert.ok(
+//         supportPanel.isOnlineSupportEnabled,
+//         'online support has been enabled'
+//       );
+
+//       assert.ok(
+//         supportPanel.isCallSupportEnabled,
+//         'call support has been enabled'
+//       );
+//     });
+
+//     test('check custom online support', function() {
+//       var onlineSupport = supportPanel.onlineSupport;
+//       assert.equal(
+//         onlineSupport.getAttribute('text'),
+//         onlineSupportTitleValue,
+//         'online support title is correct'
+//       );
+//       assert.equal(
+//         onlineSupport.getAttribute('href'),
+//         onlineSupportHrefValue,
+//         'online support href is correct'
+//       );
+//     });
+
+//     test('check custom call support', function() {
+//       var callSupports = supportPanel.callSupports;
+
+//       assert.equal(
+//         callSupports.length, 2,
+//         '2 call numbers should be displayed'
+//       );
+
+//       assert.ok(
+//         callSupports[0].getAttribute('text').indexOf(
+//           callSupport1TitleValue +
+//           ' (' + callSupport1HrefValue + ')') !== -1,
+//         'first call support title is correct'
+//       );
+//       assert.equal(
+//         callSupports[0].getAttribute('href'),
+//         callSupport1HrefValue,
+//         'first call support number is valid'
+//       );
+
+//       assert.ok(
+//         callSupports[1].getAttribute('text').indexOf(
+//           callSupport2TitleValue +
+//           ' (' + callSupport2HrefValue + ')') !== -1,
+//         'second call support title is correct'
+//       );
+//       assert.equal(
+//         callSupports[1].getAttribute('href'),
+//         callSupport2HrefValue,
+//         'second call support number is valid'
+//       );
+//     });
+
+//   });
+
+});

gaia/apps/settings/test/marionette/tests/usb_storage_settings_test.js

@@ -0,0 +1,57 @@
+'use strict';
+
+var Settings = require('../app/app'),
+    assert = require('assert');
+
+marionette('manipulate display settings', function() {
+  var client = marionette.client({
+    desiredCapabilities: { raisesAccessibilityExceptions: false }
+  });
+  var settingsApp;
+  var usbStoragePanel;
+
+  setup(function() {
+    settingsApp = new Settings(client);
+    settingsApp.launch();
+  });
+
+  suite('USB storage', function() {
+    setup(function() {
+      // Navigate to the usb storage menu
+      usbStoragePanel = settingsApp.usbStoragePanel;
+    });
+
+    suite('Check USB storage states and enable it', function() {
+      test('check default value', function() {
+        assert.ok(
+          !usbStoragePanel.isUsbEnabledSwitchChecked,
+          'USB enabled switch is un-checked by default'
+        );
+        assert.ok(
+          !usbStoragePanel.isUmsEnabled,
+          'The default value for USB setting is false'
+        );
+
+        usbStoragePanel.tapUsbEnabledSwitch();
+        client.waitFor(function() {
+          return usbStoragePanel.isUsbEnabledSwitchChecked;
+        });
+
+        usbStoragePanel.tapConfirmButton();
+        // Need to wait for a moment for the change in settings
+        client.waitFor(function() {
+          return usbStoragePanel.isUmsEnabled;
+        });
+
+        assert.ok(
+          usbStoragePanel.isUsbEnabledSwitchChecked,
+          'USB enabled switch is checked'
+        );
+        assert.ok(
+          usbStoragePanel.isUmsEnabled,
+          'USB setting value is changed'
+        );
+      });
+    });
+  });
+});