summaryrefslogtreecommitdiff
path: root/Xamarin.Forms.Core.iOS.UITests
diff options
context:
space:
mode:
authorJason Smith <jason.smith@xamarin.com>2016-03-22 20:02:25 (GMT)
committerJason Smith <jason.smith@xamarin.com>2016-03-22 23:13:41 (GMT)
commit17fdde66d94155fc62a034fa6658995bef6fd6e5 (patch)
treeb5e5073a2a7b15cdbe826faa5c763e270a505729 /Xamarin.Forms.Core.iOS.UITests
downloadxamarin-forms-17fdde66d94155fc62a034fa6658995bef6fd6e5.zip
xamarin-forms-17fdde66d94155fc62a034fa6658995bef6fd6e5.tar.gz
xamarin-forms-17fdde66d94155fc62a034fa6658995bef6fd6e5.tar.bz2
Initial import
Diffstat (limited to 'Xamarin.Forms.Core.iOS.UITests')
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/App.cs27
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/BaseTestFixture.cs76
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Makefile2
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/PlatformQueries.cs136
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Properties/AssemblyInfo.cs40
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Queries.cs165
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Remotes/BaseViewContainerRemote.cs315
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Remotes/EventViewContainerRemote.cs20
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Remotes/LayeredViewContainerRemote.cs25
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Remotes/RemoteFactory.cs56
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Remotes/StateViewContainerRemote.cs35
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Remotes/ViewContainerRemote.cs13
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Tests/ActionSheetUITests.cs171
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Tests/ActivityIndicatorUITests.cs76
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Tests/AppearingUITests.cs64
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Tests/AutomationIDUITests.cs73
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Tests/BoxViewUITests.cs57
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Tests/ButtonUITests.cs178
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Tests/ContextActionsUITests.cs129
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Tests/DatePickerUITests.cs55
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Tests/DisplayAlertUITests.cs85
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Tests/EditorUITests.cs55
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Tests/EntryUITests.cs73
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Tests/FrameUITests.cs57
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Tests/ImageUITests.cs63
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Tests/LabelUITests.cs57
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-AbsoluteLayoutGalleryTest.cs229
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-BoundViewUITest.cs96
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-ButtonUITests.cs98
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-CarouselPageUITests.cs63
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-CellsUITests.cs318
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-ClipToBoundsUITests.cs73
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-EditorUITests.cs269
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-EntryUITests.cs301
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-GridGalleryUITests.cs132
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-GroupedListActionsUITests.cs277
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-InputIntentUITests.cs190
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-ListUITests.cs92
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-MapUITests.cs110
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-MinimumSizeUITest.cs48
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-NavigationBarUITests.cs57
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-RelativeLayoutUITest.cs49
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-SearchBarUITests.cs163
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-SliderUITests.cs94
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-StackLayoutUITest.cs76
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-StepperUITests.cs93
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-SwitchUITests.cs104
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-TableViewUITests.cs76
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-TemplatedCarouselPageUITests.cs407
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-TemplatedTabPageUITests.cs346
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-ToolbarGalleryUITests.cs51
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-UnevenListTests.cs38
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-UnevenViewCellUITests.cs94
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-ViewCellUITests.cs66
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Tests/PickerUITests.cs54
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Tests/ProgressBarUITests.cs56
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Tests/RootGalleryUITests.cs88
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Tests/ScrollViewUITests.cs68
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Tests/SearchBarUITests.cs54
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Tests/SliderUITests.cs54
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Tests/StepperUITests.cs54
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Tests/SwitchUITests.cs54
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Tests/TimePickerUITests.cs56
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Tests/ToolbarItemTests.cs102
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Tests/ViewUITests.cs257
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Tests/WebViewUITests.cs93
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Utilities/AppExtensions.cs116
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Utilities/Drag.cs173
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Utilities/Gestures.cs114
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Utilities/Logger.cs71
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Utilities/NumericExtensions.cs126
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Utilities/ParsingUtils.cs89
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Utilities/UITestCustomExceptions.cs101
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Utilities/ViewInspector.cs342
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/Xamarin.Forms.Core.iOS.UITests.csproj175
-rw-r--r--Xamarin.Forms.Core.iOS.UITests/packages.config5
76 files changed, 8415 insertions, 0 deletions
diff --git a/Xamarin.Forms.Core.iOS.UITests/App.cs b/Xamarin.Forms.Core.iOS.UITests/App.cs
new file mode 100644
index 0000000..845bb9a
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/App.cs
@@ -0,0 +1,27 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+using NUnit.Framework;
+
+using Xamarin.UITest;
+using Xamarin.UITest.iOS;
+
+namespace Xamarin.Forms.Core.UITests
+{
+ internal static class RunningApp
+ {
+ public static iOSApp App;
+
+ public static void Restart ()
+ {
+ App = ConfigureApp
+ .iOS
+ .Debug ()
+ .InstalledApp ("com.xamarin.quickui.controlgallery")
+ .StartApp (Xamarin.UITest.Configuration.AppDataMode.Clear);
+ }
+ }
+} \ No newline at end of file
diff --git a/Xamarin.Forms.Core.iOS.UITests/BaseTestFixture.cs b/Xamarin.Forms.Core.iOS.UITests/BaseTestFixture.cs
new file mode 100644
index 0000000..a92d357
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/BaseTestFixture.cs
@@ -0,0 +1,76 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+using NUnit.Framework;
+
+using Xamarin.UITest;
+using Xamarin.UITest.Queries;
+
+namespace Xamarin.Forms.Core.UITests
+{
+ internal abstract class BaseTestFixture
+ {
+ // TODO: Landscape tests
+
+ public static IApp App { get; private set; }
+ public string PlatformViewType { get; protected set; }
+ public bool ShouldResetPerFixture { get; protected set; }
+ public AppRect ScreenBounds { get; private set; }
+
+ protected BaseTestFixture ()
+ {
+ ShouldResetPerFixture = true;
+ }
+
+ protected abstract void NavigateToGallery ();
+
+ [TestFixtureSetUp]
+ protected virtual void FixtureSetup ()
+ {
+ if (ShouldResetPerFixture) {
+ RelaunchApp ();
+ }
+ }
+
+ [TestFixtureTearDown]
+ protected virtual void FixtureTeardown ()
+ {
+ }
+
+ [SetUp]
+ protected virtual void TestSetup ()
+ {
+ if (!ShouldResetPerFixture) {
+ RelaunchApp ();
+ }
+ App.Screenshot ("Begin Test");
+ }
+
+ [TearDown]
+ protected virtual void TestTearDown ()
+ {
+ App.Screenshot ("Test complete");
+ }
+
+ void RelaunchApp ()
+ {
+ App = null;
+ RunningApp.App = null;
+
+ try {
+ RunningApp.Restart ();
+ } catch (Exception ex) {
+ // if at first you dont succeed
+ RunningApp.Restart ();
+ }
+ App = RunningApp.App;
+
+ App.SetOrientationPortrait ();
+ ScreenBounds = App.RootViewRect ();
+ NavigateToGallery ();
+ }
+ }
+}
diff --git a/Xamarin.Forms.Core.iOS.UITests/Makefile b/Xamarin.Forms.Core.iOS.UITests/Makefile
new file mode 100644
index 0000000..242ff29
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Makefile
@@ -0,0 +1,2 @@
+console:
+ DEBUG=1 DEVICE_TARGET=device DEVICE_ENDPOINT=http://10.0.1.159:37265 calabash-ios console
diff --git a/Xamarin.Forms.Core.iOS.UITests/PlatformQueries.cs b/Xamarin.Forms.Core.iOS.UITests/PlatformQueries.cs
new file mode 100644
index 0000000..4ae2515
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/PlatformQueries.cs
@@ -0,0 +1,136 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+using Xamarin.UITest.iOS;
+using Xamarin.UITest.Queries;
+
+namespace Xamarin.Forms.Core.UITests
+{
+ internal static class iOSLoaderIdentifier
+ {
+
+ }
+
+ internal static class PlatformMethodQueries
+ {
+ public static readonly Dictionary<BindableProperty, Tuple<string[], bool>> PropertyPlatformMethodDictionary = new Dictionary<BindableProperty, Tuple<string[], bool>> {
+ { ActivityIndicator.ColorProperty, Tuple.Create (new[] { "color" }, false) },
+ { ActivityIndicator.IsRunningProperty, Tuple.Create (new[] { "isAnimating" }, false) },
+ { Button.BorderRadiusProperty, Tuple.Create (new[] { "layer", "cornerRadius" }, false) },
+ { Button.BorderWidthProperty, Tuple.Create (new[] { "layer", "borderWidth" }, false) },
+ { Button.FontProperty, Tuple.Create (new[] { "titleLabel", "font" }, false) },
+ { Button.TextProperty, Tuple.Create (new[] { "titleLabel", "text" }, false) },
+ { Button.TextColorProperty, Tuple.Create (new[] { "titleLabel", "textColor" }, false) },
+ { View.AnchorXProperty, Tuple.Create (new[] { "layer", "transform" }, true) },
+ { View.AnchorYProperty, Tuple.Create (new[] { "layer", "transform" }, true) },
+ { View.BackgroundColorProperty, Tuple.Create (new[] { "backgroundColor" }, false) },
+ { View.IsEnabledProperty, Tuple.Create (new[] { "isEnabled" }, false) },
+ { View.OpacityProperty, Tuple.Create (new [] { "alpha" }, true) },
+ { View.RotationProperty, Tuple.Create (new[] { "layer", "transform" }, true) },
+ { View.RotationXProperty, Tuple.Create (new[] { "layer", "transform" }, true) },
+ { View.RotationYProperty, Tuple.Create (new[] { "layer", "transform" }, true) },
+ { View.ScaleProperty, Tuple.Create (new[] { "layer", "transform" }, true) },
+ };
+ }
+
+ internal static class PlatformViews
+ {
+ public static readonly string ActivityIndicator = "UIActivityIndicatorView";
+ public static readonly string BoxView = "Xamarin_Forms_Platform_iOS_BoxRenderer";
+ public static readonly string Button = "UIButton";
+ public static readonly string DatePicker = "UITextField";
+ public static readonly string Editor = "UITextView";
+ public static readonly string Entry = "UITextField";
+ public static readonly string Frame = "view:'Xamarin_Forms_Platform_iOS_FrameRenderer'";
+ public static readonly string Image = "UIImageView";
+ public static readonly string Label = "UILabel";
+ public static readonly string ListView = "UITableView";
+ public static readonly string OpenGLView = "GLKView";
+ public static readonly string Picker = "UITextField";
+ public static readonly string ProgressBar = "UIProgressView";
+ public static readonly string SearchBar = "UISearchBar";
+ public static readonly string Slider = "UISlider";
+ public static readonly string Stepper = "UIStepper";
+ public static readonly string Switch = "UISwitch";
+ public static readonly string TableView = "UITableView";
+ public static readonly string TimePicker = "UITextField";
+ public static readonly string WebView = "UIWebView";
+ }
+
+ internal static class PlatformQueries
+ {
+ public static readonly Func<AppQuery, AppQuery> Root = q => q.Class ("UIWindow");
+ public static readonly Func<AppQuery, AppQuery> RootPageListView = q => q.Class ("Xamarin_Forms_Platform_iOS_ListViewRenderer index:0");
+ public static readonly Func<AppQuery, AppQuery> GalleryListView = q => q.Class ("Xamarin_Forms_Platform_iOS_ListViewRenderer index:1");
+ public static readonly Func<AppQuery, AppQuery> PageWithoutNavigationBar = q => q.Raw ("*").Index (7);
+ public static readonly Func<AppQuery, AppQuery> NavigationBarBackButton = q => q.Class ("UINavigationItemButtonView");
+
+ // Controls
+ public static readonly Func<AppQuery, AppQuery> ActivityIndicator = q => q.ClassFull (PlatformViews.ActivityIndicator);
+ public static readonly Func<AppQuery, AppQuery> Button = q => q.ClassFull (PlatformViews.Button);
+
+ public static Func<AppQuery, AppQuery> EntryWithPlaceholder (string text) {
+ return q => q.Raw (string.Format ("TextField placeholder:'{0}'", text));
+ }
+
+ public static Func<AppQuery, AppQuery> EntryWithText (string text) {
+ return q => q.Raw (string.Format ("TextField text:'{0}'", text));
+ }
+
+ public static Func<AppQuery, AppQuery> EntryCellWithPlaceholder (string text) {
+ return q => q.Raw (string.Format ("UITextFieldLabel text:'{0}'", text));
+ }
+
+ public static Func<AppQuery, AppQuery> EntryCellWithText (string text) {
+ return q => q.Raw (string.Format ("TextField text:'{0}'", text));
+ }
+
+ public static Func<AppQuery, AppQuery> EditorsWithText (string text) {
+ return q => q.Raw (string.Format ("TextView text:'{0}'", text));
+ }
+
+ public static Func<AppQuery, AppQuery> EntryWithIndex (int index) {
+ return q => q.Raw (string.Format ("TextField index:{0}", index));
+ }
+
+ public static Func<AppQuery, AppQuery> SearchBarWithIndex (int index) {
+ return q => q.Raw (string.Format ("SearchBar index:{0}", index));
+ }
+
+ public static Func<AppQuery, AppQuery> LabelWithIndex (int index) {
+ return q => q.Raw (string.Format ("Label index:{0}", index));
+ }
+
+ public static Func<AppQuery, AppQuery> LabelWithText (string text) {
+ return q => q.Raw (string.Format ("Label text:'{0}'", text));
+ }
+
+ public static Func<AppQuery, AppQuery> LabelWithId (string id) {
+ return q => q.Raw (string.Format ("Label id:'{0}'", id));
+ }
+
+ public static Func<AppQuery, AppQuery> PickerEntryWithIndex (int index) {
+ return q => q.Raw (string.Format ("TextField index:{0}", index));
+ }
+
+ public static Func<AppQuery, AppQuery> PickerEntryWithPlaceholder (string placeholder) {
+ return q => q.Raw (string.Format ("TextField placeholder:'{0}'", placeholder));
+ }
+
+ public static Func<AppQuery, AppQuery> PickerEntryWithText (string text) {
+ return q => q.Raw (string.Format ("TextField text:'{0}'", text));
+ }
+
+ public static Func<AppQuery, AppQuery> SwitchWithIndex (int index) {
+ return q => q.Raw (string.Format ("Switch index:{0}", index));
+ }
+
+ public static Func<AppQuery, AppQuery> StepperWithIndex (int index) {
+ return q => q.Raw (string.Format ("Stepper index:{0}", index));
+ }
+
+ }
+}
diff --git a/Xamarin.Forms.Core.iOS.UITests/Properties/AssemblyInfo.cs b/Xamarin.Forms.Core.iOS.UITests/Properties/AssemblyInfo.cs
new file mode 100644
index 0000000..1246e89
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Properties/AssemblyInfo.cs
@@ -0,0 +1,40 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("Xamarin.Forms.Core.iOS.UITests")]
+[assembly: AssemblyDescription("")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("")]
+[assembly: AssemblyProduct("Xamarin.Forms.Core.iOS.UITests")]
+[assembly: AssemblyCopyright("Copyright © 2014")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible
+// to COM components. If you need to access a type in this assembly from
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("e3f6d744-9587-4d06-b7eb-5560d847c107")]
+
+// Version information for an assembly consists of the following four values:
+//
+// Major Version
+// Minor Version
+// Build Number
+// Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]
+
+[assembly: InternalsVisibleTo("Xamarin.Forms.Loader")]
+[assembly: InternalsVisibleTo("Xamarin.Forms.UITest.Validator")]
+[assembly: InternalsVisibleTo("Xamarin.Forms.UITest.TestCloud")]
diff --git a/Xamarin.Forms.Core.iOS.UITests/Queries.cs b/Xamarin.Forms.Core.iOS.UITests/Queries.cs
new file mode 100644
index 0000000..dbc8ef4
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Queries.cs
@@ -0,0 +1,165 @@
+using System;
+using System.CodeDom;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+using Xamarin.UITest;
+using Xamarin.UITest.Queries;
+
+namespace Xamarin.Forms.Core.UITests
+{
+ internal static class GalleryQueries
+ {
+ public const string AutomationIDGallery = "* marked:'AutomationID Gallery'";
+ public const string ActivityIndicatorGallery = "* marked:'ActivityIndicator Gallery'";
+ public const string BoxViewGallery = "* marked:'BoxView Gallery'";
+ public const string ButtonGallery = "* marked:'Button Gallery'";
+ public const string ContextActionsListGallery = "* marked:'ContextActions List Gallery'";
+ public const string ContextActionsTableGallery = "* marked:'ContextActions Table Gallery'";
+ public const string DatePickerGallery = "* marked:'DatePicker Gallery'";
+ public const string EditorGallery = "* marked:'Editor Gallery'";
+ public const string EntryGallery = "* marked:'Entry Gallery'";
+ public const string FrameGallery = "* marked:'Frame Gallery'";
+ public const string ImageGallery = "* marked:'Image Gallery'";
+ public const string LabelGallery = "* marked:'Label Gallery'";
+ public const string ListViewGallery = "* marked:'ListView Gallery'";
+ public const string OpenGLViewGallery = "* marked:'OpenGLView Gallery'";
+ public const string PickerGallery = "* marked:'Picker Gallery'";
+ public const string ProgressBarGallery = "* marked:'ProgressBar Gallery'";
+ public const string ScrollViewGallery = "* marked:'ScrollView Gallery'";
+ public const string ScrollViewGalleryHorizontal = "* marked:'ScrollView Gallery Horizontal'";
+ public const string SearchBarGallery = "* marked:'SearchBar Gallery'";
+ public const string SliderGallery = "* marked:'Slider Gallery'";
+ public const string StepperGallery = "* marked:'Stepper Gallery'";
+ public const string SwitchGallery = "* marked:'Switch Gallery'";
+ public const string TableViewGallery = "* marked:'TableView Gallery'";
+ public const string TimePickerGallery = "* marked:'TimePicker Gallery'";
+ public const string WebViewGallery = "* marked:'WebView Gallery'";
+ public const string ToolbarItemGallery = "* marked:'ToolbarItems Gallery'";
+ public const string DisplayAlertGallery = "* marked:'DisplayAlert Gallery'";
+ public const string ActionSheetGallery = "* marked:'ActionSheet Gallery'";
+ public const string RootPagesGallery = "* marked:'RootPages Gallery'";
+
+ public const string AppearingGallery = "* marked:'Appearing Gallery'";
+
+ // Legacy galleries
+ public const string AbsoluteLayoutGalleryLegacy = "* marked:'AbsoluteLayout Gallery - Legacy'";
+ public const string BoundPageGalleryLegacy = "* marked:'BoundPage Gallery - Legacy'";
+ public const string ButtonGalleryLegacy = "* marked:'Button Gallery - Legacy'";
+ public const string CellsGalleryLegacy = "* marked:'Cells Gallery - Legacy'";
+ public const string CarouselPageGalleryLegacy = "* marked:'CarouselPage Gallery - Legacy'";
+ public const string ClipToBoundsGalleryLegacy = "* marked:'ClipToBounds Gallery - Legacy'";
+ public const string EditorGalleryLegacy = "* marked:'Editor Gallery - Legacy'";
+ public const string EntryGalleryLegacy = "* marked:'Entry Gallery - Legacy'";
+ public const string GridGalleryLegacy = "* marked:'Grid Gallery - Legacy'";
+ public const string GroupedListActionsGalleryLegacy = "* marked:'GroupedListActions Gallery - Legacy'";
+ public const string GroupedListGalleryLegacy = "* marked:'GroupedList Gallery - Legacy'";
+ public const string InputIntentGalleryLegacy = "* marked:'InputIntent Gallery - Legacy'";
+ public const string ListViewGalleryLegacy = "* marked:'ListView Gallery - Legacy'";
+ public const string MapGalleryLegacy = "* marked:'Map Gallery - Legacy'";
+ public const string MinimumSizeGalleryLegacy = "* marked:'MinimumSize Gallery - Legacy'";
+ public const string NavigationBarGalleryLegacy = "* marked:'NavigationBar Gallery - Legacy'";
+ public const string RelativeLayoutGalleryLegacy = "* marked:'RelativeLayout Gallery - Legacy'";
+ public const string SearchBarGalleryLegacy = "* marked:'SearchBar Gallery - Legacy'";
+ public const string SliderGalleryLegacy = "* marked:'Slider Gallery - Legacy'";
+ public const string StackLayoutGalleryLegacy = "* marked:'StackLayout Gallery - Legacy'";
+ public const string StepperGalleryLegacy = "* marked:'Stepper Gallery - Legacy'";
+ public const string SwitchGalleryLegacy = "* marked:'Switch Gallery - Legacy'";
+ public const string TableViewGalleryLegacy = "* marked:'TableView Gallery - Legacy'";
+ public const string TemplatedCarouselPageGalleryLegacy = "* marked:'TemplatedCarouselPage Gallery - Legacy'";
+ public const string TemplatedTabbedPageGalleryLegacy = "* marked:'TemplatedTabbedPage Gallery - Legacy'";
+ public const string ToolbarGalleryLegacy = "* marked:'Toolbar Gallery - Legacy'";
+ public const string UnevenViewCellGalleryLegacy = "* marked:'UnevenViewCell Gallery - Legacy'";
+ public const string UnevenListGalleryLegacy = "* marked:'UnevenList Gallery - Legacy'";
+ public const string ViewCellGalleryLegacy = "* marked:'ViewCell Gallery - Legacy'";
+ }
+
+ internal static class Queries
+ {
+ #region Shared queries
+ public static Func<AppQuery, AppQuery> RootPageListView = PlatformQueries.RootPageListView;
+ public static Func<AppQuery, AppQuery> GalleryListView = PlatformQueries.GalleryListView;
+
+ public static Func<AppQuery, AppQuery> ButtonWithText (string text)
+ {
+ return q => q.Button (text);
+ }
+
+ public static Func<AppQuery, AppQuery> ElementWithText (string text)
+ {
+ return q => q.Marked (text);
+ }
+
+ public static Func<AppQuery, AppQuery> All ()
+ {
+ return q => q.All ();
+ }
+
+ #endregion
+
+ #region Platform queries
+
+ public static Func<AppQuery, AppQuery> NavigationBarBackButton ()
+ {
+ return PlatformQueries.NavigationBarBackButton;
+ }
+
+ public static Func<AppQuery, AppQuery> PageWithoutNavigationBar ()
+ {
+ return PlatformQueries.PageWithoutNavigationBar;
+ }
+
+ public static Func<AppQuery, AppQuery> Root ()
+ {
+ return PlatformQueries.Root;
+ }
+
+ public static Func<AppQuery, AppQuery> EntryCellWithPlaceholder (string placeholder)
+ {
+ return PlatformQueries.EntryCellWithPlaceholder (placeholder);
+ }
+
+ public static Func<AppQuery, AppQuery> EntryCellWithText (string placeholder)
+ {
+ return PlatformQueries.EntryCellWithText (placeholder);
+ }
+
+ #endregion
+
+ }
+
+ internal static class Views
+ {
+ public static readonly string ActivityIndicator = PlatformViews.ActivityIndicator;
+ public static readonly string BoxView = PlatformViews.BoxView;
+ public static readonly string Button = PlatformViews.Button;
+ public static readonly string DatePicker = PlatformViews.DatePicker;
+ public static readonly string Editor = PlatformViews.Editor;
+ public static readonly string Entry = PlatformViews.Entry;
+ public static readonly string Frame = PlatformViews.Frame;
+ public static readonly string Image = PlatformViews.Image;
+ public static readonly string Label = PlatformViews.Label;
+ public static readonly string ListView = PlatformViews.ListView;
+ public static readonly string OpenGLView = PlatformViews.OpenGLView;
+ public static readonly string Picker = PlatformViews.Picker;
+ public static readonly string ProgressBar = PlatformViews.ProgressBar;
+ public static readonly string SearchBar = PlatformViews.SearchBar;
+ public static readonly string Slider = PlatformViews.Slider;
+ public static readonly string Stepper = PlatformViews.Stepper;
+ public static readonly string Switch = PlatformViews.Switch;
+ public static readonly string TableView = PlatformViews.TableView;
+ public static readonly string TimePicker = PlatformViews.TimePicker;
+ public static readonly string WebView = PlatformViews.WebView;
+ }
+
+ internal static class Rects
+ {
+ public static AppRect RootViewRect (this IApp app)
+ {
+ return app.Query (q => q.Raw ("* index:0"))[0].Rect;
+ }
+ }
+}
diff --git a/Xamarin.Forms.Core.iOS.UITests/Remotes/BaseViewContainerRemote.cs b/Xamarin.Forms.Core.iOS.UITests/Remotes/BaseViewContainerRemote.cs
new file mode 100644
index 0000000..f51782c
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Remotes/BaseViewContainerRemote.cs
@@ -0,0 +1,315 @@
+using System;
+using System.Collections.Generic;
+using System.Configuration;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Runtime.Remoting.Messaging;
+using System.Security.Permissions;
+
+using NUnit.Framework;
+
+using Xamarin.UITest;
+using Xamarin.UITest.Queries;
+using Xamarin.UITest.Android;
+using Xamarin.UITest.iOS;
+using System.Globalization;
+
+
+namespace Xamarin.Forms.Core.UITests
+{
+ internal abstract class BaseViewContainerRemote
+ {
+ bool requiresDismissal;
+
+ protected IApp App { get; private set; }
+
+ public string ViewQuery { get; private set; }
+
+ public string PlatformViewType { get; set; }
+
+ public string ContainerQuery { get; private set; }
+ public string ContainerDescendents { get; private set; }
+
+ public string EventLabelQuery { get; set; }
+
+ public string StateLabelQuery { get; private set; }
+ public string StateButtonQuery { get; private set; }
+
+ public string LayeredHiddenButtonQuery { get; private set; }
+ public string LayeredLabelQuery { get; private set; }
+
+ protected BaseViewContainerRemote (IApp app, Enum formsType, string platformViewType)
+ {
+ App = app;
+ PlatformViewType = platformViewType;
+
+ // Currently tests are failing because the ViewInitilized is setting the renderer and control, fix and then remove index one
+
+ ContainerQuery = string.Format("* marked:'{0}Container'", formsType);
+ ContainerDescendents = string.Format("* marked:'{0}Container' child *", formsType);
+
+ ViewQuery = string.Format ("* marked:'{0}VisualElement'", formsType);
+
+ EventLabelQuery = string.Format ("* marked:'{0}EventLabel'", formsType);
+ StateLabelQuery = string.Format ("* marked:'{0}StateLabel'", formsType);
+ StateButtonQuery = string.Format ("* marked:'{0}StateButton'", formsType);
+ LayeredHiddenButtonQuery = string.Format ("* marked:'{0}LayeredHiddenButton'", formsType);
+ LayeredLabelQuery = string.Format ("* marked:'{0}LayeredLabel'", formsType);
+
+ if (platformViewType == PlatformViews.DatePicker) {
+ requiresDismissal = true;
+ }
+ }
+
+ public virtual void GoTo ([CallerMemberName] string callerMemberName = "")
+ {
+ var scrollBounds = App.Query (Queries.PageWithoutNavigationBar ()).First ().Rect;
+
+ // Scroll using gutter to the right of view, avoid scrolling inside of WebView
+ if (PlatformViewType == PlatformViews.WebView) {
+ scrollBounds = new AppRect {
+ X = scrollBounds.Width - 20,
+ CenterX = scrollBounds.Width - 10,
+ Y = scrollBounds.Y,
+ CenterY = scrollBounds.CenterY,
+ Width = 20,
+ Height = scrollBounds.Height,
+ };
+ }
+
+
+ while (true) {
+ var result = App.Query (o => o.Raw(ContainerQuery));
+ if (result.Any ())
+ break;
+ App.Tap (o => o.Raw ("* marked:'MoveNextButton'"));
+ }
+
+ //Assert.True (App.ScrollForElement (
+ // ContainerQuery, new Drag (scrollBounds, Drag.Direction.BottomToTop, Drag.DragLength.Medium)
+ //), "Failed to find element in: " + callerMemberName);
+
+ App.Screenshot ("Go to element");
+ }
+
+ public void TapView ()
+ {
+ App.Tap (q => q.Raw (ViewQuery));
+ }
+
+ public void DismissPopOver ()
+ {
+ App.Screenshot ("About to dismiss pop over");
+ App.Tap (q => q.Button ("Done"));
+ App.Screenshot ("Pop over dismissed");
+ }
+
+ public AppResult GetView ()
+ {
+ return App.Query (q => q.Raw (ViewQuery)).First ();
+ }
+
+ public AppResult[] GetViews ()
+ {
+ return App.Query (q => q.Raw (ViewQuery));
+ }
+
+ public AppResult[] GetContainerDescendants ()
+ {
+ return App.Query (q => q.Raw (ContainerDescendents));
+ }
+
+ public T GetProperty<T> (BindableProperty formProperty)
+ {
+ Tuple<string[], bool> property = formProperty.GetPlatformPropertyQuery ();
+ string[] propertyPath = property.Item1;
+ bool isOnParentRenderer = property.Item2;
+
+ var query = ViewQuery;
+ if (isOnParentRenderer &&
+ PlatformViewType != PlatformViews.BoxView &&
+ PlatformViewType != PlatformViews.Frame) {
+ query = query + " parent * index:0";
+ }
+
+ object prop = null;
+ bool found = false;
+
+ bool isEdgeCase = false;
+ if (App is AndroidApp && formProperty == View.ScaleProperty)
+ isEdgeCase = true;
+
+ if (!isEdgeCase) {
+ found =
+ MaybeGetProperty<string> (App, query, propertyPath, out prop) ||
+ MaybeGetProperty<float> (App, query, propertyPath, out prop) ||
+ MaybeGetProperty<bool> (App, query, propertyPath, out prop) ||
+ MaybeGetProperty<object> (App, query, propertyPath, out prop);
+ }
+
+
+ if (App is AndroidApp && formProperty == View.ScaleProperty) {
+ var matrix = new Matrix ();
+ matrix.M00 = App.Query (q => q.Raw (query).Invoke (propertyPath[0]).Value<float> ()).First ();
+ matrix.M11 = App.Query (q => q.Raw (query).Invoke (propertyPath[1]).Value<float> ()).First ();
+ matrix.M22 = 0.5f;
+ matrix.M33 = 1.0f;
+ return (T)((object)matrix);
+ }
+
+ if (!found || prop == null) {
+ throw new NullReferenceException ("null property");
+ }
+
+ if (prop.GetType () == typeof(T))
+ return (T)prop;
+
+ if (prop.GetType () == typeof(string) && typeof(T) == typeof(Matrix)) {
+ Matrix matrix = ParsingUtils.ParseCATransform3D ((string)prop);
+ return (T)((object)matrix);
+ }
+
+ if (typeof(T) == typeof(Color)) {
+ if (App is iOSApp) {
+ Color color = ParsingUtils.ParseUIColor ((string)prop);
+ return (T)((object)color);
+ } else {
+ uint intColor = (uint)((float)prop);
+ Color color = Color.FromUint (intColor);
+ return (T)((object)color);
+ }
+ }
+
+ if (prop.GetType () == typeof (string) && typeof(T) == typeof(Font)) {
+ if (App is iOSApp) {
+ Font font = ParsingUtils.ParseUIFont ((string)prop);
+ return (T)((object)font);
+ } else {
+
+ }
+ }
+
+ T result = default(T);
+
+ var stringToBoolConverter = new StringToBoolConverter ();
+ var floatToBoolConverter = new FloatToBoolConverter ();
+
+ if (stringToBoolConverter.CanConvertTo (prop, typeof(bool))) {
+ result = (T)stringToBoolConverter.ConvertTo (prop, typeof(bool));
+ } else if (floatToBoolConverter.CanConvertTo (prop, typeof(bool))) {
+ result = (T)floatToBoolConverter.ConvertTo (prop, typeof(bool));
+ }
+
+ return result;
+ }
+
+ static bool MaybeGetProperty<T>(IApp app, string query, string[] propertyPath, out object result)
+ {
+
+ try {
+ switch (propertyPath.Length){
+ case 1:
+ result = app.Query (q => q.Raw (query).Invoke (propertyPath[0]).Value<T> ()).First ();
+ break;
+ case 2:
+ result = app.Query (q => q.Raw (query).Invoke (propertyPath[0]).Invoke (propertyPath[1]).Value<T> ()).First ();
+ break;
+ case 3:
+ result = app.Query (q => q.Raw (query).Invoke (propertyPath[0]).Invoke (propertyPath[1]).Invoke (propertyPath[2]).Value<T> ()).First ();
+ break;
+ case 4:
+ result = app.Query (q => q.Raw (query).Invoke (propertyPath[0]).Invoke (propertyPath[1]).Invoke (propertyPath[2]).Invoke(propertyPath[3]).Value<T> ()).First ();
+ break;
+ default:
+ result = null;
+ return false;
+ }
+ }
+ catch {
+ result = null;
+ return false;
+ }
+
+ return true;
+ }
+
+ }
+
+ internal class StringToBoolConverter : TypeConverter
+ {
+ public override bool CanConvertTo (object source, Type targetType)
+ {
+ if (targetType != typeof(bool) || !(source is string))
+ return false;
+
+ var str = (string)source;
+ str = str.ToLowerInvariant ();
+
+ switch (str) {
+ case "0":
+ case "1":
+ case "false":
+ case "true":
+ return true;
+ default:
+ return false;
+ }
+ }
+
+ public override object ConvertTo (object source, Type targetType)
+ {
+ var str = (string)source;
+ str = str.ToLowerInvariant();
+
+ switch (str)
+ {
+ case "1":
+ case "true":
+ return true;
+ default:
+ return false;
+ }
+ }
+ }
+
+ internal class FloatToBoolConverter : TypeConverter
+ {
+ public override bool CanConvertTo (object source, Type targetType)
+ {
+ if (targetType != typeof(bool) || !(source is float))
+ return false;
+
+ var flt = (float)source;
+ var epsilon = 0.0001;
+ if (Math.Abs (flt - 1.0f) < epsilon || Math.Abs (flt - 0.0f) < epsilon)
+ return true;
+ else
+ return false;
+ }
+
+ public override object ConvertTo (object source, Type targetType)
+ {
+ var flt = (float)source;
+ var epsilon = 0.0001;
+ if (Math.Abs (flt - 1.0f) < epsilon)
+ return true;
+ else
+ return false;
+ }
+ }
+
+ internal abstract class TypeConverter
+ {
+ public abstract bool CanConvertTo (object source, Type targetType);
+
+ public abstract object ConvertTo (object source, Type targetType);
+ }
+
+ internal static class PlatformMethods
+ {
+ public static Tuple<string[], bool> GetPlatformPropertyQuery (this BindableProperty bindableProperty)
+ {
+ return PlatformMethodQueries.PropertyPlatformMethodDictionary[bindableProperty];
+ }
+ }
+} \ No newline at end of file
diff --git a/Xamarin.Forms.Core.iOS.UITests/Remotes/EventViewContainerRemote.cs b/Xamarin.Forms.Core.iOS.UITests/Remotes/EventViewContainerRemote.cs
new file mode 100644
index 0000000..d603974
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Remotes/EventViewContainerRemote.cs
@@ -0,0 +1,20 @@
+using System;
+using System.Linq;
+
+using Xamarin.UITest;
+using Xamarin.UITest.Queries;
+
+namespace Xamarin.Forms.Core.UITests
+{
+ internal sealed class EventViewContainerRemote : BaseViewContainerRemote
+ {
+ public EventViewContainerRemote (IApp app, Enum formsType, string platformViewType)
+ : base (app, formsType, platformViewType) { }
+
+ public AppResult GetEventLabel ()
+ {
+ App.WaitForElement (q => q.Raw (EventLabelQuery));
+ return App.Query (q => q.Raw (EventLabelQuery)).First ();
+ }
+ }
+} \ No newline at end of file
diff --git a/Xamarin.Forms.Core.iOS.UITests/Remotes/LayeredViewContainerRemote.cs b/Xamarin.Forms.Core.iOS.UITests/Remotes/LayeredViewContainerRemote.cs
new file mode 100644
index 0000000..6f6c107
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Remotes/LayeredViewContainerRemote.cs
@@ -0,0 +1,25 @@
+using System;
+using System.Linq;
+using System.Security.Cryptography.X509Certificates;
+
+using Xamarin.UITest;
+using Xamarin.UITest.Queries;
+
+namespace Xamarin.Forms.Core.UITests
+{
+ internal sealed class LayeredViewContainerRemote : BaseViewContainerRemote
+ {
+ public LayeredViewContainerRemote (IApp app, Enum formsType, string platformViewType)
+ : base (app, formsType, platformViewType) {}
+
+ public AppResult GetLayeredLabel ()
+ {
+ return App.Query (q => q.Raw (LayeredLabelQuery)).First ();
+ }
+
+ public void TapHiddenButton ()
+ {
+ App.Tap (q => q.Raw (LayeredHiddenButtonQuery));
+ }
+ }
+} \ No newline at end of file
diff --git a/Xamarin.Forms.Core.iOS.UITests/Remotes/RemoteFactory.cs b/Xamarin.Forms.Core.iOS.UITests/Remotes/RemoteFactory.cs
new file mode 100644
index 0000000..ec9757e
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Remotes/RemoteFactory.cs
@@ -0,0 +1,56 @@
+using System;
+
+using Xamarin.UITest;
+using Xamarin.UITest.Queries;
+
+namespace Xamarin.Forms.Core.UITests
+{
+
+// Potential cleanup of Raw Queries
+// public void MyTest(IApp app)
+// {
+// var viewName = "myView";
+//
+// app.Query (x => x.Marked (viewName + " View").Parent ().Index (0).Sibling ().Index (1).Child (0).Child (0));
+//
+// app.Query (x => x.Marked (viewName + " View").Parent (0).Sibling (1).Child (0).Child (0));
+//
+// app.Query (x => x.LayeredHiddenButton ("mine").LayeredHiddenButton ("yours"));
+//
+// app.Query (x => x.LayeredHiddenButton (viewName).Parentx(4));
+//
+// app.ForAndroid (x => {
+// x.Back();
+// });
+// }
+
+
+// Potential cleanup of Raw Queries
+// make public or reflection will not pick up in REPL
+// internal static class Exts
+// {
+// public static void ForAndroid(this IApp app, Action<AndroidApp> action)
+// {
+// if (app is AndroidApp)
+// {
+// action (app as AndroidApp);
+// }
+// }
+//
+// public static AppQuery LayeredHiddenButton(this AppQuery query, string viewName)
+// {
+// if(query.QueryPlatform == QueryPlatform.Android)
+// {
+// return query.Marked (viewName + " Android View").Parent (0).Sibling (1).Child (0).Child (0);
+//
+// }
+// return query.Marked (viewName + " iOS View").Parent (0).Sibling (1).Child (0).Child (0);
+// }
+//
+// public static AppQuery Parentx(this AppQuery query, int index)
+// {
+// return query.Parent ().Index (index);
+// }
+// }
+
+}
diff --git a/Xamarin.Forms.Core.iOS.UITests/Remotes/StateViewContainerRemote.cs b/Xamarin.Forms.Core.iOS.UITests/Remotes/StateViewContainerRemote.cs
new file mode 100644
index 0000000..2d7a117
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Remotes/StateViewContainerRemote.cs
@@ -0,0 +1,35 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Linq.Expressions;
+using System.Runtime.CompilerServices;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+using NUnit.Framework;
+
+using Xamarin.UITest;
+using Xamarin.UITest.Queries;
+
+namespace Xamarin.Forms.Core.UITests
+{
+ internal sealed class StateViewContainerRemote : BaseViewContainerRemote
+ {
+ public StateViewContainerRemote (IApp app, Enum formsType, string platformViewType)
+ : base(app, formsType, platformViewType) { }
+
+ public void TapStateButton ()
+ {
+ App.Screenshot ("Before state change");
+ App.Tap (q => q.Raw (StateButtonQuery));
+ App.Screenshot ("After state change");
+ }
+
+ public AppResult GetStateLabel ()
+ {
+ return App.Query (q => q.Raw (StateLabelQuery)).First ();
+ }
+ }
+}
diff --git a/Xamarin.Forms.Core.iOS.UITests/Remotes/ViewContainerRemote.cs b/Xamarin.Forms.Core.iOS.UITests/Remotes/ViewContainerRemote.cs
new file mode 100644
index 0000000..f19d3e6
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Remotes/ViewContainerRemote.cs
@@ -0,0 +1,13 @@
+using System;
+
+using Xamarin.UITest;
+using Xamarin.UITest.Queries;
+
+namespace Xamarin.Forms.Core.UITests
+{
+ internal sealed class ViewContainerRemote : BaseViewContainerRemote
+ {
+ public ViewContainerRemote (IApp app, Enum formsType, string platformViewType)
+ : base (app, formsType, platformViewType) { }
+ }
+} \ No newline at end of file
diff --git a/Xamarin.Forms.Core.iOS.UITests/Tests/ActionSheetUITests.cs b/Xamarin.Forms.Core.iOS.UITests/Tests/ActionSheetUITests.cs
new file mode 100644
index 0000000..9899d02
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Tests/ActionSheetUITests.cs
@@ -0,0 +1,171 @@
+using NUnit.Framework;
+using Xamarin.UITest;
+using System;
+using System.Threading;
+using Xamarin.UITest.Queries;
+
+namespace Xamarin.Forms.Core.UITests
+{
+ [TestFixture]
+ [Category ("ActionSheet")]
+ internal class ActionSheetUITests : BaseTestFixture
+ {
+ AppRect screenSize;
+
+ public ActionSheetUITests ()
+ {
+
+ }
+
+ protected override void NavigateToGallery ()
+ {
+ App.NavigateToGallery (GalleryQueries.ActionSheetGallery);
+ }
+
+ static void CheckExtras ()
+ {
+ App.WaitForElement (c => c.Marked ("Extra One"));
+ App.WaitForElement (c => c.Marked ("Extra Eight"));
+ }
+
+ protected override void TestSetup ()
+ {
+ base.TestSetup ();
+ screenSize = App.Query (q => q.Marked ("ActionSheetPage"))[0].Rect;
+ }
+
+ [Test]
+ public void TestDisplayActionSheet ()
+ {
+ ScrollAndTap ("ActionSheet Extras");
+ CheckExtras ();
+ App.Tap (c => c.Marked ("Extra One"));
+ }
+
+ [Test]
+ public void TestDisplayActionSheetCancel ()
+ {
+ ScrollAndTap ("ActionSheet Cancel");
+ // iPad does not have a Cancel button for action sheet
+ if (App.Query (q => q.Marked ("Cancel")).Length > 0)
+ App.Tap (c => c.Marked ("Cancel"));
+ else
+ App.TapCoordinates (20, screenSize.Height / 2);
+ }
+
+ [Test]
+ public void TestDisplayActionSheetCancelDestruction ()
+ {
+ ScrollAndTap ("ActionSheet Cancel Destruction");
+ App.WaitForNoElement (c => c.Marked ("Extra One"));
+ App.WaitForElement (c => c.Marked ("Destruction"));
+ if (App.Query (q => q.Marked ("Cancel")).Length > 0)
+ App.Tap (c => c.Marked ("Cancel"));
+ else
+ App.TapCoordinates (20, screenSize.Height / 2);
+ }
+
+ [Test]
+ public void TestDisplayActionSheetCancelExtras ()
+ {
+ ScrollAndTap ("ActionSheet Cancel Extras");
+ CheckExtras ();
+ if (App.Query (q => q.Marked ("Cancel")).Length > 0)
+ App.Tap (c => c.Marked ("Cancel"));
+ else
+ App.TapCoordinates (20, screenSize.Height / 2);
+ }
+
+ [Test]
+ public void TestDisplayActionSheetCancelExtrasDestruction ()
+ {
+ ScrollAndTap ("ActionSheet Cancel Destruction Extras");
+ CheckExtras ();
+ App.WaitForElement (c => c.Marked ("Destruction"));
+ if (App.Query (q => q.Marked ("Cancel")).Length > 0)
+ App.Tap (c => c.Marked ("Cancel"));
+ else
+ App.TapCoordinates (20, screenSize.Height / 2);
+ }
+
+ [Test]
+ public void TestDisplayActionSheetDestruction ()
+ {
+ ScrollAndTap ("ActionSheet Destruction");
+ App.WaitForNoElement (c => c.Marked ("Extra One"));
+ App.Tap (c => c.Marked ("Destruction"));
+ }
+
+ [Test]
+ public void TestDisplayActionSheetDestructionExtras ()
+ {
+ ScrollAndTap ("ActionSheet Destruction Extras");
+ CheckExtras ();
+ App.Tap (c => c.Marked ("Extra One"));
+ }
+
+ [Test]
+ public void TestDisplayActionSheetTitleCancel ()
+ {
+ ScrollAndTap ("ActionSheet Title Cancel");
+ App.WaitForElement (c => c.Marked ("Title"));
+ if (App.Query (q => q.Marked ("Cancel")).Length > 0)
+ App.Tap (c => c.Marked ("Cancel"));
+ else
+ App.TapCoordinates (20, screenSize.Height / 2);
+ }
+
+ [Test]
+ public void TestDisplayActionSheetTitleCancelDestruction ()
+ {
+ ScrollAndTap ("ActionSheet Title Cancel Destruction");
+ App.WaitForElement (c => c.Marked ("Title"));
+ App.WaitForNoElement (c => c.Marked ("Extra One"));
+ App.Tap (c => c.Marked ("Destruction"));
+ }
+
+ [Test]
+ public void TestDisplayActionSheetTitleCancelDestructionExtras ()
+ {
+ ScrollAndTap ("ActionSheet Title Cancel Destruction Extras");
+ App.WaitForElement (c => c.Marked ("Title"));
+ CheckExtras ();
+ App.Tap (c => c.Marked ("Destruction"));
+ }
+
+ [Test]
+ public void TestDisplayActionSheetTitleDestruction ()
+ {
+ ScrollAndTap ("ActionSheet Title Destruction");
+ App.WaitForElement (c => c.Marked ("Title"));
+ App.WaitForNoElement (c => c.Marked ("Extra One"));
+ App.Tap (c => c.Marked ("Destruction"));
+ }
+
+ [Test]
+ public void TestDisplayActionSheetTitleDestructionExtras ()
+ {
+ ScrollAndTap ("ActionSheet Title Destruction Extras");
+ App.WaitForElement (c => c.Marked ("Title"));
+ CheckExtras ();
+ App.Tap (c => c.Marked ("Destruction"));
+ }
+
+
+ [Test]
+ public void TestDisplayActionSheetTitleExtras ()
+ {
+ ScrollAndTap ("ActionSheet Title Extras");
+ CheckExtras ();
+ App.Tap (c => c.Marked ("Extra One"));
+ }
+
+ void ScrollAndTap(string actionSheet)
+ {
+ App.ScrollForElement(string.Format("* text:'{0}'", actionSheet), new Drag(App.Query(q => q.Marked("ActionSheetPage"))[0].Rect, Drag.Direction.BottomToTop, Drag.DragLength.Long));
+ App.Tap(q=>q.Raw(string.Format("* text:'{0}'", actionSheet)));
+ }
+
+ }
+}
+
diff --git a/Xamarin.Forms.Core.iOS.UITests/Tests/ActivityIndicatorUITests.cs b/Xamarin.Forms.Core.iOS.UITests/Tests/ActivityIndicatorUITests.cs
new file mode 100644
index 0000000..325a568
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Tests/ActivityIndicatorUITests.cs
@@ -0,0 +1,76 @@
+using System;
+using System.IO;
+using System.Linq;
+
+using NUnit.Framework;
+
+using Xamarin.Forms.CustomAttributes;
+using Xamarin.UITest.Queries;
+
+namespace Xamarin.Forms.Core.UITests
+{
+ [TestFixture]
+ [Category ("ActivityIndicator")]
+ internal class ActivityIndicatorUITests : _ViewUITests
+ {
+ public ActivityIndicatorUITests ()
+ {
+ PlatformViewType = Views.ActivityIndicator;
+ }
+
+ protected override void NavigateToGallery ()
+ {
+ App.NavigateToGallery (GalleryQueries.ActivityIndicatorGallery);
+ }
+
+ // View tests
+ [UiTestExempt (ExemptReason.CannotTest, "Invalid interaction")]
+ public override void _Focus () {}
+
+ public override void _GestureRecognizers ()
+ {
+ // TODO Can implement this
+ var remote = new ViewContainerRemote (App, Test.View.GestureRecognizers, PlatformViewType);
+ remote.GoTo ();
+ }
+ [UiTestExempt (ExemptReason.CannotTest, "Invalid interaction")]
+ public override void _IsEnabled () {}
+
+ [UiTestExempt (ExemptReason.CannotTest, "Invalid interaction")]
+ public override void _IsFocused () {}
+
+ [UiTestExempt (ExemptReason.CannotTest, "Invalid interaction")]
+ public override void _UnFocus () {}
+
+ //[UiTest (typeof(ActivityIndicator), "Color")]
+ public void Color ()
+ {
+ //TODO: this was failing and is changing in next version of calabash (UI-Test-pre nuget) to a json rgb
+
+// var remote = RemoteFactory.CreateRemote<ViewContainerRemote> (App, "Color", PlatformViewType);
+// remote.GoTo ();
+//
+// var color = remote.GetProperty<Color> (ActivityIndicator.ColorProperty);
+// Assert.AreEqual (Forms.Color.Lime, color);
+ }
+
+ // ActivityIndicator tests
+ [Test]
+ [UiTest (typeof(ActivityIndicator), "IsRunning")]
+ public void IsRunning ()
+ {
+ var remote = new ViewContainerRemote (App, Test.ActivityIndicator.IsRunning, PlatformViewType);
+ remote.GoTo ();
+
+ var isRunning = remote.GetProperty<bool> (ActivityIndicator.IsRunningProperty);
+ Assert.IsTrue (isRunning);
+ }
+
+ protected override void FixtureTeardown ()
+ {
+ App.NavigateBack ();
+ base.FixtureTeardown ();
+ }
+
+ }
+} \ No newline at end of file
diff --git a/Xamarin.Forms.Core.iOS.UITests/Tests/AppearingUITests.cs b/Xamarin.Forms.Core.iOS.UITests/Tests/AppearingUITests.cs
new file mode 100644
index 0000000..c346b4f
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Tests/AppearingUITests.cs
@@ -0,0 +1,64 @@
+using System;
+using NUnit.Framework;
+
+namespace Xamarin.Forms.Core.UITests
+{
+ [Category ("Lifecycle")]
+ internal class AppearingUITests : BaseTestFixture
+ {
+
+ public AppearingUITests ()
+ {
+ ShouldResetPerFixture = false;
+ }
+
+ protected override void NavigateToGallery ()
+ {
+ App.NavigateToGallery (GalleryQueries.AppearingGallery);
+ }
+
+ [Test]
+ public void AppearingNavigationPage ()
+ {
+ App.Tap (t => t.Marked ("NavAppearingPage"));
+ App.WaitForElement ("Appearing NavAppearingPage");
+ App.WaitForElement ("Appearing Page 1");
+ App.Tap (t => t.Marked ("Push new Page"));
+ App.WaitForElement ("Disappearing Page 1");
+ App.WaitForElement ("Appearing Page 2");
+ App.Tap (t => t.Marked ("Change Main Page"));
+ App.WaitForElement ("Disappearing Page 2");
+ App.WaitForElement ("Disappearing NavAppearingPage");
+ App.WaitForElement ("Appearing Page 3");
+ }
+
+
+ [Test]
+ public void AppearingCarouselPage ()
+ {
+ App.Tap (t => t.Marked ("CarouselAppearingPage"));
+ App.WaitForElement ("Appearing CarouselAppearingPage");
+ App.WaitForElement ("Appearing Page 1");
+
+ }
+
+ [Test]
+ public void AppearingTabbedPage ()
+ {
+ App.Tap (t => t.Marked ("TabbedAppearingPage"));
+ App.WaitForElement ("Appearing TabbedAppearingPage");
+ App.WaitForElement ("Appearing Page 1");
+
+ }
+
+ [Test]
+ public void AppearingMasterDetailPage ()
+ {
+ App.Tap (t => t.Marked ("MasterAppearingPage"));
+ App.WaitForElement ("Appearing MasterAppearingPage");
+ App.WaitForElement ("Appearing Page 1");
+
+ }
+ }
+}
+
diff --git a/Xamarin.Forms.Core.iOS.UITests/Tests/AutomationIDUITests.cs b/Xamarin.Forms.Core.iOS.UITests/Tests/AutomationIDUITests.cs
new file mode 100644
index 0000000..7746baf
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Tests/AutomationIDUITests.cs
@@ -0,0 +1,73 @@
+using NUnit.Framework;
+using Xamarin.UITest;
+using System;
+using System.Threading;
+using Xamarin.UITest.Queries;
+
+namespace Xamarin.Forms.Core.UITests
+{
+ [TestFixture]
+ [Category ("AutomationID")]
+ internal class AutomationIDUITests : BaseTestFixture
+ {
+ protected override void NavigateToGallery ()
+ {
+ App.NavigateToGallery (GalleryQueries.AutomationIDGallery);
+ }
+
+ [Test]
+ public void Test1 ()
+ {
+ App.Tap (c => c.Marked ("btnTest1"));
+ App.WaitForElement (c => c.Marked ("scrollMain"));
+ App.WaitForElement (c => c.Marked ("stckMain"));
+ App.WaitForElement (c => c.Marked ("actHello"));
+ App.WaitForElement (c => c.Marked ("bxvHello"));
+ App.Tap (c => c.Marked ("btnHello"));
+ App.WaitForElement (c => c.Marked ("dtPicker"));
+ App.WaitForElement (c => c.Marked ("tPicker"));
+
+ var label = App.Query ("lblHello") [0];
+ Assert.AreEqual (label.Text, "Hello Label");
+
+ var editor = App.Query ("editorHello") [0];
+ Assert.AreEqual (editor.Text, "Hello Editor");
+
+ var entry = App.Query ("entryHello") [0];
+ Assert.AreEqual (entry.Text, "Hello Entry");
+
+ App.Tap (c => c.Marked ("popModal"));
+ }
+
+
+ [Test]
+ public void Test2 ()
+ {
+ App.Tap (c => c.Marked ("btnTest2"));
+ App.WaitForElement (c => c.Marked ("imgHello"));
+ App.WaitForElement (c => c.Marked ("lstView"));
+ App.WaitForElement (c => c.Marked ("pickerHello"));
+ App.WaitForElement (c => c.Marked ("progressHello"));
+ App.ScrollDownTo (c => c.Marked ("progressHello"));
+ App.WaitForElement (c => c.Marked ("srbHello"));
+ App.WaitForElement (c => c.Marked ("sliHello"));
+ App.WaitForElement (c => c.Marked ("stepperHello"));
+ App.WaitForElement (c => c.Marked ("switchHello"));
+ //App.WaitForElement (c => c.Marked ("webviewHello"));
+ App.Tap (c => c.Marked ("popModal"));
+ }
+
+ [Test]
+ [Ignore("only works on ios")]
+ public void TestToolbarItem ()
+ {
+ App.Tap (c => c.Marked ("tbItemHello"));
+ App.WaitForElement (x => x.Marked ("Hello"));
+ App.Tap (c => c.Marked ("ok"));
+ App.Tap (c => c.Marked ("tbItemHello2"));
+ App.WaitForElement (x => x.Marked ("Hello2"));
+ App.Tap (c => c.Marked ("ok"));
+ }
+ }
+}
+
diff --git a/Xamarin.Forms.Core.iOS.UITests/Tests/BoxViewUITests.cs b/Xamarin.Forms.Core.iOS.UITests/Tests/BoxViewUITests.cs
new file mode 100644
index 0000000..cf542c3
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Tests/BoxViewUITests.cs
@@ -0,0 +1,57 @@
+using System;
+using System.CodeDom;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Security.Cryptography;
+using System.Threading;
+using System.Reflection;
+
+using NUnit.Framework;
+
+using Xamarin.Forms.CustomAttributes;
+using Xamarin.UITest.Android;
+using Xamarin.UITest.Queries;
+using Xamarin.UITest.iOS;
+
+namespace Xamarin.Forms.Core.UITests
+{
+ [TestFixture]
+ [Category ("BoxView")]
+ internal class BoxViewUITests : _ViewUITests
+ {
+ public BoxViewUITests ()
+ {
+ PlatformViewType = Views.BoxView;
+ }
+
+ protected override void NavigateToGallery ()
+ {
+ App.NavigateToGallery (GalleryQueries.BoxViewGallery);
+ }
+
+ [UiTestExempt (ExemptReason.CannotTest, "Invalid interaction")]
+ public override void _Focus () {}
+
+ // TODO
+ public override void _GestureRecognizers () {}
+
+ [UiTestExempt (ExemptReason.CannotTest, "Invalid interaction")]
+ public override void _IsFocused () {}
+
+ [UiTestExempt (ExemptReason.CannotTest, "Invalid interaction")]
+ public override void _UnFocus () {}
+
+ // TODO
+ // Implement control specific ui tests
+
+ protected override void FixtureTeardown ()
+ {
+ App.NavigateBack ();
+ base.FixtureTeardown ();
+ }
+
+ [UiTestExempt (ExemptReason.CannotTest, "Invalid interaction")]
+ public override void _IsEnabled () {}
+ }
+} \ No newline at end of file
diff --git a/Xamarin.Forms.Core.iOS.UITests/Tests/ButtonUITests.cs b/Xamarin.Forms.Core.iOS.UITests/Tests/ButtonUITests.cs
new file mode 100644
index 0000000..5ae8f50
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Tests/ButtonUITests.cs
@@ -0,0 +1,178 @@
+using System;
+using System.CodeDom;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Security.Cryptography;
+using System.Threading;
+using System.Reflection;
+
+using NUnit.Framework;
+
+using Xamarin.Forms.CustomAttributes;
+using Xamarin.UITest.Android;
+using Xamarin.UITest.Queries;
+using Xamarin.UITest.iOS;
+
+namespace Xamarin.Forms.Core.UITests
+{
+ [TestFixture]
+ [Category ("Button")]
+ internal class ButtonUITests : _ViewUITests
+ {
+ public ButtonUITests ()
+ {
+ PlatformViewType = Views.Button;
+ }
+
+ protected override void NavigateToGallery ()
+ {
+ App.NavigateToGallery (GalleryQueries.ButtonGallery);
+ }
+
+ // View Tests
+ [UiTestExempt (ExemptReason.CannotTest, "Invalid interaction")]
+ public override void _Focus () {}
+
+ [UiTestExempt (ExemptReason.CannotTest, "Invalid interaction")]
+ public override void _GestureRecognizers () {}
+
+ [UiTestExempt (ExemptReason.CannotTest, "Invalid interaction")]
+ public override void _IsFocused () {}
+
+ [UiTestExempt (ExemptReason.CannotTest, "Invalid interaction")]
+ public override void _UnFocus () {}
+
+ // Button Tests
+ [Test]
+ [UiTest (typeof(Button),"BorderColor")]
+ [UiTestBroken (BrokenReason.CalabashAndroidUnsupported, "Figure out how to get Android Drawables")]
+ [UiTestBroken (BrokenReason.CalabashiOSUnsupported, "iOS nil result")]
+ public void BorderColor ()
+ {
+ //TODO iOS
+ var remote = new ViewContainerRemote (App, Test.Button.BorderColor, PlatformViewType);
+ remote.GoTo ();
+
+ }
+
+ [Test]
+ [UiTest (typeof (Button), "BorderRadius")]
+ [UiTestBroken (BrokenReason.CalabashAndroidUnsupported, "Figure out how to get Android Drawables")]
+ public void BorderRadius ()
+ {
+ var remote = new ViewContainerRemote (App, Test.Button.BorderRadius, PlatformViewType);
+ remote.GoTo ();
+
+ if (App is iOSApp) {
+ var borderRadius = remote.GetProperty<float> (Button.BorderRadiusProperty);
+ Assert.AreEqual (20.0f, borderRadius);
+ }
+
+ }
+
+ [Test]
+ [UiTest (typeof (Button), "BorderWidth")]
+ [UiTestBroken (BrokenReason.CalabashAndroidUnsupported, "Figure out how to get Android Drawables")]
+ public void BorderWidth ()
+ {
+ var remote = new ViewContainerRemote (App, Test.Button.BorderWidth, PlatformViewType);
+ remote.GoTo ();
+
+ if (App is iOSApp) {
+ var borderWidth = remote.GetProperty<float> (Button.BorderWidthProperty);
+ Assert.AreEqual (15.0f, borderWidth);
+ }
+
+ }
+
+ [Test]
+ [UiTest (typeof (Button), "Clicked")]
+ public void Clicked ()
+ {
+ var remote = new EventViewContainerRemote (App, Test.Button.Clicked, PlatformViewType);
+ remote.GoTo ();
+
+ var textBeforeClick = remote.GetEventLabel ().Text;
+ Assert.AreEqual ("Event: Clicked (none)", textBeforeClick);
+
+ // Click Button
+ remote.TapView ();
+
+ var textAfterClick = remote.GetEventLabel ().Text;
+ Assert.AreEqual ("Event: Clicked (fired 1)", textAfterClick);
+ }
+
+ [Test]
+ [UiTest (typeof (Button), "Command")]
+ public void Command ()
+ {
+ var remote = new ViewContainerRemote (App, Test.Button.Command, PlatformViewType);
+ remote.GoTo ();
+
+ remote.TapView ();
+
+ App.WaitForElement (q => q.Marked ("Hello Command"));
+ App.Tap (q => q.Marked ("Destroy"));
+ }
+
+ [Test]
+ [UiTest (typeof (Button), "Font")]
+ public void Font ()
+ {
+ //TODO iOS
+ var remote = new ViewContainerRemote (App, Test.Button.Font, PlatformViewType);
+ remote.GoTo ();
+
+ if (App is AndroidApp) {
+ var isBold = remote.GetProperty<bool> (Button.FontProperty);
+ Assert.True (isBold);
+ } else {
+ var font = remote.GetProperty<Font> (Button.FontProperty);
+ Assert.True (font.FontAttributes.HasFlag (FontAttributes.Bold));
+ }
+
+ }
+
+ [Test]
+ [UiTest (typeof (Button), "Image")]
+ [UiTestExempt (ExemptReason.TimeConsuming, "Need way to check Android resources")]
+ public void Image ()
+ {
+ //TODO iOS
+ var remote = new ViewContainerRemote (App, Test.Button.Image, PlatformViewType);
+ remote.GoTo ();
+ }
+
+ [Test]
+ [UiTest (typeof (Button), "Text")]
+ public void Text ()
+ {
+ var remote = new ViewContainerRemote (App, Test.Button.Text, PlatformViewType);
+ remote.GoTo ();
+
+ var buttonText = remote.GetProperty<string> (Button.TextProperty);
+ Assert.AreEqual ("Text", buttonText);
+ }
+
+ [Test]
+ [UiTest (typeof (Button), "TextColor")]
+ public void TextColor ()
+ {
+ //TODO iOS
+ if (App is AndroidApp) {
+ var remote = new ViewContainerRemote (App, Test.Button.TextColor, PlatformViewType);
+ remote.GoTo ();
+
+ var buttonTextColor = remote.GetProperty<Color> (Button.TextColorProperty);
+ Assert.AreEqual (Color.Pink, buttonTextColor);
+ }
+ }
+
+ protected override void FixtureTeardown ()
+ {
+ App.NavigateBack ();
+ base.FixtureTeardown ();
+ }
+ }
+} \ No newline at end of file
diff --git a/Xamarin.Forms.Core.iOS.UITests/Tests/ContextActionsUITests.cs b/Xamarin.Forms.Core.iOS.UITests/Tests/ContextActionsUITests.cs
new file mode 100644
index 0000000..7691dd4
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Tests/ContextActionsUITests.cs
@@ -0,0 +1,129 @@
+using NUnit.Framework;
+using Xamarin.UITest;
+using System;
+using System.Threading;
+
+using Xamarin.UITest.Android;
+using Xamarin.UITest.iOS;
+using Xamarin.UITest.Queries;
+
+namespace Xamarin.Forms.Core.UITests
+{
+ [TestFixture]
+ [Category ("Cells")]
+ internal class ContextActionsListUITests : BaseTestFixture
+ {
+
+ public ContextActionsListUITests ()
+ {
+ ShouldResetPerFixture = false;
+ }
+
+ protected override void NavigateToGallery ()
+ {
+ App.NavigateToGallery (GalleryQueries.ContextActionsListGallery);
+ }
+
+ const string cell0 = "Subject Line 0";
+ const string cell1 = "Subject Line 1";
+ const string move = "Move";
+ const string delete = "Delete";
+ const string clear = "Clear Items";
+ const string mark = "Mark";
+
+ [Test]
+ public void ContextActionsShow ()
+ {
+ if (App is AndroidApp) {
+ // mark is an icon on android
+ App.TouchAndHold (q => q.Marked (cell0));
+ App.WaitForElement (q => q.Marked (delete));
+ App.Screenshot ("I have actions!");
+ } else if (App is iOSApp) {
+ Assert.Inconclusive ("Not tested on iOS yet");
+ }
+ }
+
+ [Test]
+ public void ContextActionsDelete ()
+ {
+ if (App is AndroidApp) {
+ // mark is an icon on android
+ App.TouchAndHold (q => q.Marked (cell0));
+ App.WaitForElement (q => q.Marked (delete));
+ App.Screenshot ("I have actions!");
+
+ App.Tap (q => q.Marked (delete));
+ App.WaitForNoElement (q => q.Marked (cell0));
+ App.Screenshot ("Deleted cell 0");
+
+ } else if (App is iOSApp) {
+ Assert.Inconclusive ("Not tested on iOS yet");
+ }
+ }
+
+ [Test]
+ public void PopoverDismiss()
+ {
+ if (App is iOSApp) {
+ var app = ((iOSApp)App);
+ if (app.Device.IsTablet) {
+ var screenBounds = App.Query (PlatformQueries.Root)[0].Rect;
+ var cellBounds = App.Query (q => q.Marked (cell0))[0].Rect;
+ App.DragCoordinates (screenBounds.Width - 10, cellBounds.CenterY, 10, cellBounds.CenterY);
+ App.Screenshot("I see context actions");
+ App.Tap (q => q.Marked ("More"));
+ App.Screenshot ("Should see Popover");
+ App.TapCoordinates (50, 50);
+ App.Screenshot ("I should not crash");
+ } else {
+ Assert.Inconclusive("Not testing iOS Phone");
+ }
+ } else {
+ Assert.Inconclusive ("Not testing on Android");
+ }
+ }
+ }
+
+ [TestFixture]
+ [Category ("Cells")]
+ internal class ContextActionsTableUITests : BaseTestFixture
+ {
+ public ContextActionsTableUITests ()
+ {
+ ShouldResetPerFixture = false;
+ }
+
+ protected override void NavigateToGallery ()
+ {
+ App.NavigateToGallery (GalleryQueries.ContextActionsTableGallery);
+ }
+
+ const string cell0 = "Subject Line 0";
+ const string cell1 = "Subject Line 1";
+ const string move = "Move";
+ const string delete = "Delete";
+ const string clear = "Clear Items";
+ const string mark = "Mark";
+ const string cellWithNoContextActions = "I have no ContextActions";
+
+ [Test]
+ public void ContextActionsShowAndReset ()
+ {
+ if (App is AndroidApp) {
+ // mark is an icon on android
+ App.TouchAndHold (q => q.Marked (cell0));
+ App.WaitForElement (q => q.Marked (delete));
+ App.Screenshot ("I have actions!");
+
+ App.Tap (q => q.Marked (cellWithNoContextActions));
+ App.WaitForNoElement (q => q.Marked (delete));
+ App.Screenshot ("Actions should be gone");
+
+ } else if (App is iOSApp) {
+ Assert.Inconclusive ("Not tested on iOS yet");
+ }
+ }
+ }
+}
+
diff --git a/Xamarin.Forms.Core.iOS.UITests/Tests/DatePickerUITests.cs b/Xamarin.Forms.Core.iOS.UITests/Tests/DatePickerUITests.cs
new file mode 100644
index 0000000..5769f71
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Tests/DatePickerUITests.cs
@@ -0,0 +1,55 @@
+using System;
+using System.CodeDom;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Security.Cryptography;
+using System.Threading;
+using System.Reflection;
+
+using NUnit.Framework;
+
+using Xamarin.Forms.CustomAttributes;
+using Xamarin.UITest.Android;
+using Xamarin.UITest.Queries;
+using Xamarin.UITest.iOS;
+
+namespace Xamarin.Forms.Core.UITests
+{
+ [TestFixture]
+ [Category ("DatePicker")]
+ internal class DatePickerUITests : _ViewUITests
+ {
+ public DatePickerUITests ()
+ {
+ PlatformViewType = Views.DatePicker;
+ }
+
+ protected override void NavigateToGallery ()
+ {
+ App.NavigateToGallery (GalleryQueries.DatePickerGallery);
+ }
+
+ // View Tests
+ // TODO
+ public override void _Focus () {}
+
+ [UiTestExempt (ExemptReason.CannotTest, "Invalid interaction")]
+ public override void _GestureRecognizers () {}
+
+ // TODO
+ public override void _IsFocused () {}
+
+ // TODO
+ public override void _UnFocus () {}
+
+ // TODO
+ // Implement control specific ui tests
+
+ protected override void FixtureTeardown ()
+ {
+ App.NavigateBack ();
+ base.FixtureTeardown ();
+ }
+ }
+} \ No newline at end of file
diff --git a/Xamarin.Forms.Core.iOS.UITests/Tests/DisplayAlertUITests.cs b/Xamarin.Forms.Core.iOS.UITests/Tests/DisplayAlertUITests.cs
new file mode 100644
index 0000000..be0e499
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Tests/DisplayAlertUITests.cs
@@ -0,0 +1,85 @@
+using NUnit.Framework;
+using Xamarin.UITest;
+using System;
+using System.Threading;
+
+
+namespace Xamarin.Forms.Core.UITests
+{
+ [TestFixture]
+ [Category ("DisplayAlert")]
+ internal class DisplayAlertUITests : BaseTestFixture
+ {
+
+ protected override void NavigateToGallery ()
+ {
+ App.NavigateToGallery (GalleryQueries.DisplayAlertGallery);
+ }
+
+ [Test]
+ public void TestWithCancelButton ()
+ {
+
+ App.Tap (c => c.Marked ("Alert Override1"));
+ App.Screenshot ("Display Alert");
+ App.WaitForElement (c => c.Marked ("TheAlertTitle"));
+ App.WaitForElement (c => c.Marked ("TheAlertMessage"));
+ App.WaitForElement (c => c.Marked ("TheCancelButton"));
+ App.Screenshot ("Display Alert Closed");
+ App.Tap (c => c.Marked ("TheCancelButton"));
+ App.WaitForNoElement (c => c.Marked ("TheAlertTitle"));
+ }
+
+ [Test]
+ public void TestWithCancelAndOkButton ()
+ {
+ App.Tap (c => c.Marked ("Alert Override2"));
+ App.Screenshot ("Display Alert");
+ App.WaitForElement (c => c.Marked ("TheAlertTitle"));
+ App.WaitForElement (c => c.Marked ("TheAlertMessage"));
+ App.WaitForElement (c => c.Marked ("TheAcceptButton"));
+ App.WaitForElement (c => c.Marked ("TheCancelButton"));
+ App.Tap (c => c.Marked ("TheCancelButton"));
+ App.Screenshot ("Display Alert Closed");
+ App.WaitForNoElement (c => c.Marked ("TheAlertTitle"));
+ }
+
+ [Test]
+ public void TestOkAndCancelResults ()
+ {
+ App.Tap (c => c.Marked ("Alert Override2"));
+ App.Screenshot ("Display Alert");
+ App.WaitForElement (c => c.Marked ("TheCancelButton"));
+ App.Tap (c => c.Marked ("TheCancelButton"));
+ App.Screenshot ("Display Alert Closed with cancel");
+ App.WaitForElement (c => c.Marked ("Result: False"));
+ App.Tap (c => c.Marked ("test2"));
+ App.Screenshot ("Display Alert");
+ App.WaitForElement (c => c.Marked ("TheAcceptButton"));
+ App.Tap (c => c.Marked ("TheAcceptButton"));
+ App.Screenshot ("Display Alert Closed with True");
+ App.WaitForElement (c => c.Marked ("Result: True"));
+ }
+
+// [Test]
+// public void TestRotation ()
+// {
+// App.SetOrientationLandscape ();
+//
+// //App.Tap (c => c.Marked ("Alert Override1"));
+// // 27-01-2015 14:30:02.125 -08:00 - 28524 - Tapping first element (2 total) matching Marked("Alert Override1") at coordinates [ 512, 113 ].
+//
+// App.TapCoordinates (665, 512);
+//
+// App.WaitForElement (c => c.Marked ("TheAlertTitle"));
+//
+// App.Screenshot ("Display Alert After Rotation");
+// App.WaitForElement (c => c.Marked ("TheAlertTitle"));
+// App.Tap (c => c.Marked("TheCancelButton"));
+// App.WaitForNoElement (c => c.Marked("TheCancelButton"));
+// App.SetOrientationPortrait ();
+//
+// }
+
+ }
+}
diff --git a/Xamarin.Forms.Core.iOS.UITests/Tests/EditorUITests.cs b/Xamarin.Forms.Core.iOS.UITests/Tests/EditorUITests.cs
new file mode 100644
index 0000000..6701faa
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Tests/EditorUITests.cs
@@ -0,0 +1,55 @@
+using System;
+using System.CodeDom;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Security.Cryptography;
+using System.Threading;
+using System.Reflection;
+
+using NUnit.Framework;
+
+using Xamarin.Forms.CustomAttributes;
+using Xamarin.UITest.Android;
+using Xamarin.UITest.Queries;
+using Xamarin.UITest.iOS;
+
+namespace Xamarin.Forms.Core.UITests
+{
+ [TestFixture]
+ [Category ("Editor")]
+ internal class EditorUITests : _ViewUITests
+ {
+ public EditorUITests ()
+ {
+ PlatformViewType = Views.Editor;
+ }
+
+ protected override void NavigateToGallery ()
+ {
+ App.NavigateToGallery (GalleryQueries.EditorGallery);
+ }
+
+ // View Tests
+ // TODO
+ public override void _Focus () {}
+
+ [UiTestExempt (ExemptReason.CannotTest, "Invalid interaction")]
+ public override void _GestureRecognizers () {}
+
+ // TODO
+ public override void _IsFocused () {}
+
+ // TODO
+ public override void _UnFocus () {}
+
+ // TODO
+ // Implement control specific ui tests
+
+ protected override void FixtureTeardown ()
+ {
+ App.NavigateBack ();
+ base.FixtureTeardown ();
+ }
+ }
+} \ No newline at end of file
diff --git a/Xamarin.Forms.Core.iOS.UITests/Tests/EntryUITests.cs b/Xamarin.Forms.Core.iOS.UITests/Tests/EntryUITests.cs
new file mode 100644
index 0000000..45b7337
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Tests/EntryUITests.cs
@@ -0,0 +1,73 @@
+using System;
+using System.CodeDom;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Security.Cryptography;
+using System.Threading;
+using System.Reflection;
+
+using NUnit.Framework;
+
+using Xamarin.Forms.CustomAttributes;
+using Xamarin.UITest.Android;
+using Xamarin.UITest.Queries;
+using Xamarin.UITest.iOS;
+
+namespace Xamarin.Forms.Core.UITests
+{
+ [TestFixture]
+ [Category ("Entry")]
+ internal class EntryUITests : _ViewUITests
+ {
+ public EntryUITests ()
+ {
+ PlatformViewType = Views.Entry;
+ }
+
+ protected override void NavigateToGallery ()
+ {
+ App.NavigateToGallery (GalleryQueries.EntryGallery);
+ }
+
+ // TODO
+ public override void _Focus () {}
+
+ [UiTestExempt (ExemptReason.CannotTest, "Invalid interaction")]
+ public override void _GestureRecognizers () {}
+
+ // TODO
+ public override void _IsFocused () {}
+
+ // TODO
+ public override void _UnFocus () {}
+
+ // TODO
+ // Implement control specific ui tests
+ [Test]
+ [UiTest (typeof(Entry), "Completed")]
+ public void Completed ()
+ {
+ var remote = new EventViewContainerRemote (App, Test.Entry.Completed, PlatformViewType);
+ remote.GoTo ();
+
+ App.EnterText (q=> q.Raw (remote.ViewQuery), "Test");
+
+ if (App is AndroidApp) {
+ ((AndroidApp)App).PressUserAction (UserAction.Done);
+ } else {
+ App.PressEnter ();
+ }
+
+ var eventLabelText = remote.GetEventLabel ().Text;
+ Assert.AreEqual (eventLabelText, "Event: Completed (fired 1)");
+ }
+
+ protected override void FixtureTeardown ()
+ {
+ App.NavigateBack ();
+ base.FixtureTeardown ();
+ }
+
+ }
+} \ No newline at end of file
diff --git a/Xamarin.Forms.Core.iOS.UITests/Tests/FrameUITests.cs b/Xamarin.Forms.Core.iOS.UITests/Tests/FrameUITests.cs
new file mode 100644
index 0000000..f7a59ed
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Tests/FrameUITests.cs
@@ -0,0 +1,57 @@
+using System;
+using System.CodeDom;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Security.Cryptography;
+using System.Threading;
+using System.Reflection;
+
+using NUnit.Framework;
+
+using Xamarin.Forms.CustomAttributes;
+using Xamarin.UITest.Android;
+using Xamarin.UITest.Queries;
+using Xamarin.UITest.iOS;
+
+namespace Xamarin.Forms.Core.UITests
+{
+ [TestFixture]
+ [Category ("Frame")]
+ internal class FrameUITests : _ViewUITests
+ {
+ public FrameUITests ()
+ {
+ PlatformViewType = Views.Frame;
+ }
+
+ protected override void NavigateToGallery ()
+ {
+ App.NavigateToGallery (GalleryQueries.FrameGallery);
+ }
+
+ [UiTestExempt (ExemptReason.CannotTest, "Invalid interaction")]
+ public override void _Focus () {}
+
+ // TODO
+ public override void _GestureRecognizers () {}
+
+ [UiTestExempt (ExemptReason.CannotTest, "Invalid interaction")]
+ public override void _IsFocused () {}
+
+ [UiTestExempt (ExemptReason.CannotTest, "Invalid interaction")]
+ public override void _UnFocus () {}
+
+ // TODO
+ // Implement control specific ui tests
+
+ protected override void FixtureTeardown ()
+ {
+ App.NavigateBack ();
+ base.FixtureTeardown ();
+ }
+
+ [UiTestExempt (ExemptReason.CannotTest, "Invalid interaction")]
+ public override void _IsEnabled () {}
+ }
+} \ No newline at end of file
diff --git a/Xamarin.Forms.Core.iOS.UITests/Tests/ImageUITests.cs b/Xamarin.Forms.Core.iOS.UITests/Tests/ImageUITests.cs
new file mode 100644
index 0000000..5c19d1c
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Tests/ImageUITests.cs
@@ -0,0 +1,63 @@
+using System;
+using System.CodeDom;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Security.Cryptography;
+using System.Threading;
+using System.Reflection;
+
+using NUnit.Framework;
+
+using Xamarin.Forms.CustomAttributes;
+using Xamarin.UITest.Android;
+using Xamarin.UITest.Queries;
+using Xamarin.UITest.iOS;
+
+namespace Xamarin.Forms.Core.UITests
+{
+ [TestFixture]
+ [Category ("Image")]
+ internal class ImageUITests : _ViewUITests
+ {
+ public ImageUITests ()
+ {
+ PlatformViewType = Views.Image;
+ }
+
+ protected override void NavigateToGallery ()
+ {
+ App.NavigateToGallery (GalleryQueries.ImageGallery);
+
+ // let remote images load
+ Thread.Sleep (2000);
+ }
+
+ [UiTestExempt (ExemptReason.CannotTest, "Invalid interaction")]
+ public override void _Focus () {}
+
+ // TODO
+ public override void _GestureRecognizers () {}
+
+ [UiTestExempt (ExemptReason.CannotTest, "Invalid interaction")]
+ public override void _IsEnabled () {}
+
+ [UiTestExempt (ExemptReason.CannotTest, "Invalid interaction")]
+ public override void _IsFocused () {}
+
+ [UiTestExempt (ExemptReason.CannotTest, "Invalid interaction")]
+ public override void _UnFocus () {}
+
+ // TODO
+ // Implement control specific ui tests
+
+ // TODO
+ // Tests for remote images
+
+ protected override void FixtureTeardown ()
+ {
+ App.NavigateBack ();
+ base.FixtureTeardown ();
+ }
+ }
+} \ No newline at end of file
diff --git a/Xamarin.Forms.Core.iOS.UITests/Tests/LabelUITests.cs b/Xamarin.Forms.Core.iOS.UITests/Tests/LabelUITests.cs
new file mode 100644
index 0000000..423774f
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Tests/LabelUITests.cs
@@ -0,0 +1,57 @@
+using System;
+using System.CodeDom;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Security.Cryptography;
+using System.Threading;
+using System.Reflection;
+
+using NUnit.Framework;
+
+using Xamarin.Forms.CustomAttributes;
+using Xamarin.UITest.Android;
+using Xamarin.UITest.Queries;
+using Xamarin.UITest.iOS;
+
+namespace Xamarin.Forms.Core.UITests
+{
+ [TestFixture]
+ [Category ("Label")]
+ internal class LabelUITests : _ViewUITests
+ {
+ public LabelUITests ()
+ {
+ PlatformViewType = Views.Label;
+ }
+
+ protected override void NavigateToGallery ()
+ {
+ App.NavigateToGallery (GalleryQueries.LabelGallery);
+ }
+
+ [UiTestExempt (ExemptReason.CannotTest, "Invalid interaction")]
+ public override void _Focus () {}
+
+ // TODO
+ public override void _GestureRecognizers () {}
+
+ [UiTestExempt (ExemptReason.CannotTest, "Invalid interaction")]
+ public override void _IsEnabled () {}
+
+ [UiTestExempt (ExemptReason.CannotTest, "Invalid interaction")]
+ public override void _IsFocused () {}
+
+ [UiTestExempt (ExemptReason.CannotTest, "Invalid interaction")]
+ public override void _UnFocus () {}
+
+ // TODO
+ // Implement control specific ui tests
+
+ protected override void FixtureTeardown ()
+ {
+ App.NavigateBack ();
+ base.FixtureTeardown ();
+ }
+ }
+} \ No newline at end of file
diff --git a/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-AbsoluteLayoutGalleryTest.cs b/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-AbsoluteLayoutGalleryTest.cs
new file mode 100644
index 0000000..c23a0d2
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-AbsoluteLayoutGalleryTest.cs
@@ -0,0 +1,229 @@
+using NUnit.Framework;
+using Xamarin.UITest;
+using System;
+using System.Threading;
+using Xamarin.UITest.Queries;
+using System.Diagnostics;
+
+namespace Xamarin.Forms.Core.UITests
+{
+ [TestFixture]
+ [Category ("AbsoluteLayout")]
+ internal class AbsoluteLayoutGalleryTests : BaseTestFixture
+ {
+ // TODO: Port to new conventions
+
+ public AbsoluteLayoutGalleryTests ()
+ {
+ ShouldResetPerFixture = false;
+ }
+
+ protected override void NavigateToGallery ()
+ {
+ App.NavigateToGallery (GalleryQueries.AbsoluteLayoutGalleryLegacy);
+ }
+
+ [Test]
+ public void AbsoluteLayoutGalleryMoveBox ()
+ {
+ App.Screenshot ("At Gallery");
+
+ // App.WaitForElement (q => q.Raw (Views.BoxView), "Timeout : Box Renderers");
+ // Assert.AreEqual (1, App.Query (q => q.Raw (Views.BoxView)).Length);
+
+ // App.WaitForElement (q => q.Raw (Views.Label), "Timeout : Labels");
+ // Assert.AreEqual (4, App.Query(q => q.Raw (Views.Label)).Length);
+
+ // App.WaitForElement (q => q.Raw (Views.Slider), "Timeout : Sliders");
+ // Assert.AreEqual (4, App.Query(q => q.Raw (Views.Slider)).Length);
+ // App.Screenshot ("All elements exist");
+
+ // App.WaitForElement (q => q.Raw (Views.Slider));
+ // // Move green box left
+ // var sliders = (App.Query (q => q.Raw (Views.Slider)));
+ // var sliderCenter = (sliders[0]).Rect.CenterX;
+ // var sliderLeft = (sliders[0]).Rect.X;
+ // var sliderRight = sliderLeft + (sliders[0]).Rect.Width;
+
+ // var xSlider = (sliders[0]).Rect.CenterY;
+ // var ySlider = (sliders[1]).Rect.CenterY;
+
+ //var absoluteBounds = App.Query (PlatformQueries.AbsoluteGalleryBackground)[0].Rect;
+
+ //// Move box left
+ //App.DragFromTo (sliderCenter, xSlider, sliderLeft, xSlider, Speed.Slow);
+ //Assert.AreEqual (absoluteBounds.X, (App.Query (PlatformQueries.BoxRendererQuery))[0].Rect.X, 2.0);
+ //App.Screenshot ("Box moved to left bounds");
+
+ //// Move box right
+ //App.DragFromTo (sliderLeft, xSlider, sliderRight, xSlider, Speed.Slow);
+ //Assert.AreEqual (absoluteBounds.X + absoluteBounds.Width, (App.Query (PlatformQueries.BoxRendererQuery))[0].Rect.X + (App.Query (PlatformQueries.BoxRendererQuery))[0].Rect.Width, 2.0);
+ //App.Screenshot ("Box moved to right bounds");
+
+ ////Move box up
+ //var boxContainer = App.Query (PlatformQueries.AbsoluteGalleryBackground)[0];
+ //var boxContainerTop = boxContainer.Rect.Y;
+ //var boxContainerBottom = boxContainer.Rect.Y + boxContainer.Rect.Height;
+
+ //App.DragFromTo (sliderCenter, ySlider, sliderLeft, ySlider, Speed.Slow);
+ //Assert.AreEqual (boxContainerTop, (App.Query (PlatformQueries.BoxRendererQuery))[0].Rect.Y);
+ //App.Screenshot ("Box moved to top bounds");
+
+ //// Move box down
+ //App.DragFromTo (sliderLeft, ySlider, sliderRight, ySlider, Speed.Slow);
+ //Assert.AreEqual (boxContainerBottom, (App.Query (PlatformQueries.BoxRendererQuery))[0].Rect.Y + (App.Query (PlatformQueries.BoxRendererQuery))[0].Rect.Height);
+ //App.Screenshot ("Box moved to bottom bounds");
+ }
+
+ //[Test]
+ //[Description ("MaxWidth")]
+ //public void AbsoluteLayoutGalleryResizeToMaximumWidth ()
+ //{
+ //App.WaitForElement (PlatformQueries.Sliders, "Timeout : Sliders");
+
+ //AppRect widthSlider = (App.Query (PlatformQueries.Sliders))[2].Rect;
+ //float sliderCenter = widthSlider.CenterX;
+ //float sliderY = widthSlider.CenterY;
+ //float sliderRight = widthSlider.X + widthSlider.Width;
+
+ //App.DragFromTo (sliderCenter, sliderY, sliderRight, sliderY, Speed.Slow);
+
+ //AppRect absoluteBounds = App.Query (PlatformQueries.AbsoluteGalleryBackground)[0].Rect;
+ //AppRect boxBounds = App.Query (PlatformQueries.BoxRendererQuery)[0].Rect;
+
+ //Assert.AreEqual (absoluteBounds.Width, boxBounds.Width, 2.0);
+ //App.Screenshot ("Box at maximum width");
+ //}
+
+ //[Test]
+ //[Description ("MaxHeight")]
+ //public void AbsoluteLayoutGalleryResizeToMaximumHeight ()
+ //{
+ //App.WaitForElement (PlatformQueries.Sliders, "Timeout : Sliders");
+
+ //AppRect widthSlider = (App.Query (PlatformQueries.Sliders))[3].Rect;
+ //float sliderCenter = widthSlider.CenterX;
+ //float sliderY = widthSlider.CenterY;
+ //float sliderRight = widthSlider.X + widthSlider.Width;
+
+ //App.DragFromTo (sliderCenter, sliderY, sliderRight, sliderY, Speed.Slow);
+
+ //AppRect absoluteBounds = App.Query (PlatformQueries.AbsoluteGalleryBackground)[0].Rect;
+ //AppRect boxBounds = App.Query (PlatformQueries.BoxRendererQuery)[0].Rect;
+
+ //Assert.AreEqual (absoluteBounds.Height, boxBounds.Height, 2.0);
+ //App.Screenshot ("Box at maximum height");
+ //}
+
+ //[Test]
+ //[Description ("MinWidth")]
+ //public void AbsoluteLayoutGalleryResizeToMinimumWidth ()
+ //{
+ //App.WaitForElement (PlatformQueries.Sliders, "Timeout : Sliders");
+
+ //AppRect widthSlider = (App.Query (PlatformQueries.Sliders))[2].Rect;
+ //float sliderCenter = widthSlider.CenterX;
+ //float sliderY = widthSlider.CenterY;
+ //float sliderLeft = widthSlider.X - 20;
+
+ //App.DragFromTo (sliderCenter, sliderY, sliderLeft, sliderY, Speed.Slow);
+
+ //bool isZeroed = false;
+ //if (App.Query (PlatformQueries.BoxRendererQuery).Length == 0) {
+ // // Android removes 0 width BoxView
+ // isZeroed = true;
+ //} else {
+ // if (App.Query (PlatformQueries.BoxRendererQuery)[0].Rect.Width <= 4.0)
+ // isZeroed = true;
+ //}
+
+ //Assert.IsTrue (isZeroed, "Box is minimum width");
+ //App.Screenshot ("Box at minimum width");
+ }
+
+ //[Test]
+ //[Description ("MinHeight")]
+ //public void AbsoluteLayoutGalleryResizeToMinimumHeight ()
+ //{
+ //App.WaitForElement (PlatformQueries.Sliders, "Timeout : Sliders");
+
+ //AppRect widthSlider = (App.Query (PlatformQueries.Sliders))[3].Rect;
+ //float sliderCenter = widthSlider.CenterX;
+ //float sliderY = widthSlider.CenterY;
+ //float sliderLeft = widthSlider.X - 20;
+
+ //App.DragFromTo (sliderCenter, sliderY, sliderLeft, sliderY, Speed.Slow);
+
+ //bool isZeroed = false;
+ //if (App.Query (PlatformQueries.BoxRendererQuery).Length == 0) {
+ // // Android removes 0 height BoxView
+ // isZeroed = true;
+ //} else {
+ // if (App.Query (PlatformQueries.BoxRendererQuery)[0].Rect.Height <= 4.0)
+ // isZeroed = true;
+ //}
+
+ //Assert.IsTrue (isZeroed, "Box is minimum height");
+ //App.Screenshot ("Box at minimum height");
+ //}
+
+/*******************************************************/
+/**************** Landscape tests **********************/
+/*******************************************************/
+
+ //[Test]
+ //[Description ("Move box around with sliders - landscape")]
+ //public void AbsoluteLayoutGalleryMoveBoxLandscape ()
+ //{
+ // App.SetOrientationLandscape ();
+ // App.Screenshot ("Rotated to Landscape");
+ // AbsoluteLayoutGalleryMoveBox ();
+ // App.SetOrientationPortrait ();
+ // App.Screenshot ("Rotated to Portrait");
+ //}
+
+ //[Test]
+ //[Description ("Resize to max width with sliders - landscape")]
+ //public void AbsoluteLayoutGalleryResizeToMaximumWidthLandscape ()
+ //{
+ // App.SetOrientationLandscape ();
+ // App.Screenshot ("Rotated to Landscape");
+ // AbsoluteLayoutGalleryResizeToMaximumWidth ();
+ // App.SetOrientationPortrait ();
+ // App.Screenshot ("Rotated to Portrait");
+ //}
+
+ //[Test]
+ //[Description ("Resize to max height with sliders - landscape")]
+ //public void AbsoluteLayoutGalleryResizeToMaximumHeightLandscape ()
+ //{
+ // App.SetOrientationLandscape ();
+ // App.Screenshot ("Rotated to Landscape");
+ // AbsoluteLayoutGalleryResizeToMaximumHeight ();
+ // App.SetOrientationPortrait ();
+ // App.Screenshot ("Rotated to Portrait");
+ //}
+
+ //[Test]
+ //[Description ("Resize to min height with sliders - landscape")]
+ //public void AbsoluteLayoutGalleryResizeToMinimumWidthLandscape ()
+ //{
+ // App.SetOrientationLandscape ();
+ // App.Screenshot ("Rotated to Landscape");
+ // AbsoluteLayoutGalleryResizeToMinimumWidth ();
+ // App.SetOrientationPortrait ();
+ // App.Screenshot ("Rotated to Portrait");
+ //}
+
+ //[Test]
+ //[Description ("Resize to min height with sliders - landscape")]
+ //public void AbsoluteLayoutGalleryResizeToMinimumHeightLandscape ()
+ //{
+ // App.SetOrientationLandscape ();
+ // App.Screenshot ("Rotated to Landscape");
+ // AbsoluteLayoutGalleryResizeToMinimumHeight ();
+ // App.SetOrientationPortrait ();
+ // App.Screenshot ("Rotated to Portrait");
+ //}
+ //}
+}
diff --git a/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-BoundViewUITest.cs b/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-BoundViewUITest.cs
new file mode 100644
index 0000000..625a27c
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-BoundViewUITest.cs
@@ -0,0 +1,96 @@
+using NUnit.Framework;
+using Xamarin.UITest;
+using System;
+using System.Threading;
+
+namespace Xamarin.Forms.Core.UITests
+{
+ [TestFixture]
+ [Category ("Templated")]
+ internal class BoundViewGalleryTests : BaseTestFixture
+ {
+ // TODO: Port to new conventions
+
+ public BoundViewGalleryTests ()
+ {
+ ShouldResetPerFixture = false;
+ }
+
+ protected override void NavigateToGallery ()
+ {
+ App.NavigateToGallery (GalleryQueries.BoundPageGalleryLegacy);
+ }
+
+ //void AllElementsPresent ()
+ //{
+ // App.WaitForElement (q => q.Button ("Click Me!"));
+ // App.Screenshot ("All elements present");
+ //}
+
+ [Test]
+ [Description ("Test bound view navigation")]
+ public void BoundViewGalleryNavigateToAndBack ()
+ {
+ App.Screenshot ("At Gallery");
+
+// AllElementsPresent ();
+
+// App.Tap (q => q.Button ("Click Me!"));
+// App.WaitForElement (q => q.Marked ("Second Page"), "Timeout : Second Page");
+// App.Screenshot ("Navigation to next page successful");
+
+// App.Tap (PlatformQueries.Back);
+// App.WaitForElement (q => q.Button ("Click Me!"), "Timeout : Click Me!");
+// App.Screenshot ("Navigation back successful");
+ }
+
+// [Test]
+// [Description ("Test button click")]
+// public void BoundViewGalleryClickButton ()
+// {
+// App.Tap (q => q.Button ("Click Me!"));
+// App.WaitForElement (q => q.Marked ("Second Page"), "Timeout : Second Page");
+// }
+
+///*******************************************************/
+///**************** Landscape tests **********************/
+///*******************************************************/
+
+// [Test]
+// [Description ("Verify all elements are preset - landscape")]
+// public void BoundViewGalleryAllElementsPresentLandscape ()
+// {
+// App.SetOrientationLandscape ();
+// Thread.Sleep (1000);
+// App.Screenshot ("Rotated to Landscape");
+// AllElementsPresent ();
+// App.SetOrientationPortrait ();
+// App.Screenshot ("Rotated to Portrait");
+// }
+
+// [Test]
+// [Description ("Test bound view navigation- landscape")]
+// public void BoundViewGalleryNavigateToAndBackLandscape ()
+// {
+// App.SetOrientationLandscape ();
+// Thread.Sleep (1000);
+// App.Screenshot ("Rotated to Landscape");
+// BoundViewGalleryNavigateToAndBack ();
+// App.SetOrientationPortrait ();
+// App.Screenshot ("Rotated to Portrait");
+// }
+
+// [Test]
+// [Description ("Test button click - landscape")]
+// public void BoundViewGalleryClickButtonLandscape ()
+// {
+// App.SetOrientationLandscape ();
+// Thread.Sleep (1000);
+// App.Screenshot ("Rotated to Landscape");
+// BoundViewGalleryClickButton ();
+// App.SetOrientationPortrait ();
+// App.Screenshot ("Rotated to Portrait");
+// }
+
+ }
+}
diff --git a/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-ButtonUITests.cs b/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-ButtonUITests.cs
new file mode 100644
index 0000000..71443ce
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-ButtonUITests.cs
@@ -0,0 +1,98 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using NUnit.Framework;
+
+namespace Xamarin.Forms.Core.UITests
+{
+ // Run these to test in CI before full suite
+ [TestFixture]
+ [Category ("Button")]
+ internal class ButtonGalleryTests : BaseTestFixture
+ {
+ // TODO: Rotate Button - test rotation
+ // TODO: Port to new conventions
+
+ public ButtonGalleryTests ()
+ {
+ ShouldResetPerFixture = false;
+ }
+
+ protected override void NavigateToGallery ()
+ {
+ App.NavigateToGallery (GalleryQueries.ButtonGalleryLegacy);
+ }
+
+ [Test]
+ [Description ("Disabled Button")]
+ public void ButtonGalleryOnOffDisbledButton ()
+ {
+ App.Screenshot ("At Gallery");
+
+ // App.ScrollDownForElement (q => q.Marked ("Cannot Tap"), 3);
+ // App.Tap (q => q.Button ("Disabled Button"));
+ // Assert.AreEqual (1, App.Query (q => q.Button ("Disabled Button")).Length);
+ // App.Screenshot ("Tried to tap disabled button");
+ // App.Tap (PlatformQueries.Switch);
+ // App.Screenshot ("Tapped switch");
+ // App.Tap (q => q.Button ("Disabled Button"));
+ // App.WaitForElement (q => q.Marked ("TAPPED!"));
+ // App.Screenshot ("Disabled button should not be enabled and change labels text");
+ }
+
+ //[Test]
+ //[UiTest (Test.Device.StartTimer)]
+ //[Description ("Clicking the 'Timer Button'")]
+ //public void ButtonGalleryTimerButton ()
+ //{
+ // App.ScrollDownForElement (q => q.Marked ("Timer"), 10);
+ // App.Screenshot ("Press 'Timer' Button");
+
+ // App.Tap (q => q.Button ("Timer"));
+
+ // App.WaitForElement (q => q.Marked ("Timer Elapsed 3"), "Timeout : Timer Elapsed 3");
+ // App.Screenshot ("Timer button elapsed 3");
+ //}
+
+ //[Test]
+ //[UiTest (Test.Page.DisplayAlert)]
+ //public void ButtonGalleryAlertAccepted ()
+ //{
+ // App.ScrollDownForElement (q => q.Marked ("Alert"), 10);
+
+ // App.Screenshot ("Press 'Alert' Button");
+
+ // App.Tap (q => q.Marked ("Alert"));
+ // App.WaitForElement (q => q.Marked ("Accept"), "Timeout : Accept");
+
+ // App.Screenshot ("Press 'Accept' or 'Cancel'");
+
+ // App.Tap (q => q.Marked ("Accept"));
+ // App.WaitForElement (q => q.Button ("Accepted"), "Timeout : Accepted");
+
+ // App.Screenshot ("See 'Accepted' or 'Cancelled'");
+ //}
+
+
+ //[Test]
+ //[UiTest (Test.Page.DisplayAlert)]
+ //public void ButtonGalleryAlertCancelled ()
+ //{
+ // App.ScrollDownForElement (q => q.Marked ("Alert"), 10);
+
+ // App.Screenshot ("Press 'Alert' Button");
+
+ // App.Tap (q => q.Marked ("Alert"));
+ // App.WaitForElement (q => q.Marked ("Cancel"), "Timeout : Cancel");
+
+ // App.Screenshot ("Press 'Accept' or 'Cancel'");
+
+ // App.Tap (q => q.Marked ("Cancel"));
+ // App.WaitForElement (q => q.Button ("Cancelled"), "Timeout : Cancelled");
+
+ // App.Screenshot ("See 'Accepted' or 'Cancelled'");
+ //}
+ }
+}
diff --git a/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-CarouselPageUITests.cs b/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-CarouselPageUITests.cs
new file mode 100644
index 0000000..14a6ed4
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-CarouselPageUITests.cs
@@ -0,0 +1,63 @@
+using NUnit.Framework;
+
+using Xamarin.Forms.CustomAttributes;
+using Xamarin.UITest;
+
+namespace Xamarin.Forms.Core.UITests
+{
+ [TestFixture]
+ [Category ("CarouselPage")]
+ internal class CarouselPageGalleryTests : BaseTestFixture
+ {
+ // TODO: Port to new conventions
+
+ public CarouselPageGalleryTests ()
+ {
+ ShouldResetPerFixture = false;
+ }
+
+ protected override void NavigateToGallery ()
+ {
+ App.NavigateToGallery (GalleryQueries.CarouselPageGalleryLegacy);
+ }
+
+ [Test]
+ [Description ("Swiping between screens")]
+ [UiTest (typeof(CarouselPage))]
+ public void CarouselPageGallerySwipeScreens ()
+ {
+ App.Screenshot ("At Gallery");
+
+ // var rootViewWidth = App.Query (q => q.Raw ("*"))[0].Rect.Width;
+ // var rootViewHeight = App.Query (q => q.Raw ("*"))[0].Rect.Height;
+
+ // // Verify the elements can be touched
+ // App.Tap (q => q.Button ("Click me one"));
+ // App.WaitForNoElement (q => q.Marked ("No click one"), "Timeout : No click one");
+ // App.WaitForElement (q => q.Marked ("Clicked one"), "Timeout : Clicked one");
+
+ // App.Pan (new Drag (ScreenBounds, rootViewWidth - 20, rootViewHeight / 2, 20, rootViewHeight / 2, Drag.Direction.RightToLeft));
+
+ // App.WaitForElement (q => q.Marked ("No click two"), "Timeout : No click two");
+ // App.WaitForElement (q => q.Button ("Click me two"), "Timeout : Click me two");
+ // App.Screenshot ("On page two");
+
+ // // Verify the elements can be touched
+ // App.Tap (q => q.Button ("Click me two"));
+ // App.WaitForNoElement (q => q.Marked ("No click two"), "Timeout : No click two");
+ // App.WaitForElement (q => q.Marked ("Clicked two"), "Timeout : Clicked two");
+
+ // App.Pan (new Drag (ScreenBounds, rootViewWidth - 20, rootViewHeight / 2, 20, rootViewHeight / 2, Drag.Direction.RightToLeft));
+
+ // App.WaitForElement (q => q.Marked ("No click three"), "Timeout : No click three");
+ // App.WaitForElement (q => q.Button ("Click me three"), "Timeout : Click me three");
+ // App.Screenshot ("On page three");
+
+ // // Verify the elements can be touched
+ // App.Tap (q => q.Button ("Click me three"));
+ // App.WaitForNoElement (q => q.Marked ("No click three"), "Timeout : No click three");
+ // App.WaitForElement (q => q.Marked ("Clicked three"), "Clicked three");
+ // App.Screenshot ("All screens interacted with");
+ }
+ }
+}
diff --git a/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-CellsUITests.cs b/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-CellsUITests.cs
new file mode 100644
index 0000000..e6efd5f
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-CellsUITests.cs
@@ -0,0 +1,318 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+
+using NUnit.Framework;
+
+using Xamarin.Forms.CustomAttributes;
+using Xamarin.UITest;
+using Xamarin.UITest.Android;
+using Xamarin.UITest.Queries;
+
+namespace Xamarin.Forms.Core.UITests
+{
+ [TestFixture]
+ [Category ("Cells")]
+ internal class CellsGalleryTests : BaseTestFixture
+ {
+ // TODO find a way to test individula elements of cells
+ // TODO port to new framework
+
+ protected override void NavigateToGallery ()
+ {
+ App.NavigateToGallery (GalleryQueries.CellsGalleryLegacy);
+ }
+
+ [Test]
+ [Description ("ListView with TextCells, all are present")]
+ [UiTest (typeof(ListView))]
+ [UiTest (typeof(TextCell))]
+ public void CellsGalleryTextCellList ()
+ {
+ App.ScrollForElement ("* marked:'TextCell List'", new Drag (ScreenBounds, Drag.Direction.BottomToTop, Drag.DragLength.Medium));
+ App.Tap (q => q.Marked ("TextCell List"));
+ App.WaitForElement (q => q.Marked ("Text 0"), "Timeout : Text 0");
+
+ App.Screenshot ("At TextCell List Gallery");
+
+ App.ScrollForElement ("* marked:'Detail 99'", new Drag (ScreenBounds, Drag.Direction.BottomToTop, Drag.DragLength.Medium));
+
+ App.WaitForElement (q => q.Marked ("Detail 99"), "Timeout : Detail 99");
+
+ App.Screenshot ("All TextCells are present");
+ }
+
+ [Test]
+ [Description ("TableView with TextCells, all are present")]
+ [UiTest (typeof(TableView))]
+ [UiTest (typeof(TextCell))]
+ public void CellsGalleryTextCellTable ()
+ {
+ App.ScrollForElement ("* marked:'TextCell Table'", new Drag (ScreenBounds, Drag.Direction.BottomToTop, Drag.DragLength.Medium));
+
+ App.Tap (q => q.Marked ("TextCell Table"));
+ App.WaitForElement (q => q.Marked ("Text 1"), "Timeout : Text 1");
+
+ App.Screenshot ("At TextCell Table Gallery");
+
+ App.ScrollForElement ("* marked:'Detail 12'", new Drag (ScreenBounds, Drag.Direction.BottomToTop, Drag.DragLength.Medium));
+
+ App.WaitForElement (q => q.Marked ("Detail 12"), "Timeout : Detail 12");
+
+ App.Screenshot ("All TextCells are present");
+ }
+
+ [Test]
+ [Description ("ListView with ImageCells, all are present")]
+ [UiTest (typeof(ListView))]
+ [UiTest (typeof(ImageCell))]
+ public void CellsGalleryImageCellList ()
+ {
+ Thread.Sleep (2000);
+
+ App.ScrollForElement ("* marked:'ImageCell List'", new Drag (ScreenBounds, Drag.Direction.BottomToTop, Drag.DragLength.Medium));
+
+ Thread.Sleep (2000);
+
+ App.Tap (q => q.Marked ("ImageCell List"));
+ App.WaitForElement (q => q.Marked ("Text 0"), "Timeout : Text 0");
+
+ App.Screenshot ("At ImageCell List Gallery");
+
+ var scollBounds = App.Query (q => q.Marked ("ImageCellListView")).First ().Rect;
+ App.ScrollForElement ("* marked:'Detail 99'", new Drag (scollBounds, Drag.Direction.BottomToTop, Drag.DragLength.Medium));
+
+ App.WaitForElement (q => q.Marked ("Detail 99"), "Timeout : Detail 99");
+
+ App.Screenshot ("All ImageCells are present");
+
+ var numberOfImages = App.Query (q => q.Raw (PlatformViews.Image)).Length;
+ // Check that there are images present. In Android,
+ // have to make sure that there are more than 2 for navigation.
+ Assert.IsTrue (numberOfImages > 2);
+
+ App.Screenshot ("Images are present");
+ }
+
+ [Test]
+ [Description ("ListView with ImageCells, file access problems")]
+ [UiTest (typeof(ListView))]
+ [UiTest (typeof(ImageCell))]
+ public void CellsGalleryImageUrlCellList ()
+ {
+
+ App.ScrollForElement ("* marked:'ImageCell Url List'", new Drag (ScreenBounds, Drag.Direction.BottomToTop, Drag.DragLength.Medium));
+
+ App.Tap (q => q.Marked ("ImageCell Url List"));
+
+ var scollBounds = App.Query (q => q.Marked ("ImageUrlCellListView")).First ().Rect;
+ App.ScrollForElement ("* marked:'Detail 200'", new Drag (scollBounds, Drag.Direction.BottomToTop, Drag.DragLength.Long), 40);
+
+ App.WaitForElement (q => q.Marked ("Detail 200"), "Timeout : Detail 200");
+
+ App.Screenshot ("All ImageCells are present");
+
+ var numberOfImages = App.Query (q => q.Raw (PlatformViews.Image)).Length;
+ // Check that there are images present. In Android,
+ // have to make sure that there are more than 2 for navigation.
+ Assert.IsTrue (numberOfImages > 2);
+
+ App.Screenshot ("Images are present");
+ }
+
+
+
+
+ [Test]
+ [Description ("TableView with ImageCells, all are present")]
+ [UiTest (typeof(TableView))]
+ [UiTest (typeof(ImageCell))]
+ public void CellsGalleryImageCellTable ()
+ {
+ App.ScrollForElement ("* marked:'ImageCell Table'", new Drag (ScreenBounds, Drag.Direction.BottomToTop, Drag.DragLength.Medium));
+
+ App.Tap (q => q.Marked ("ImageCell Table"));
+ App.WaitForElement (q => q.Marked ("Text 1"), "Timeout : Text 1");
+
+ App.Screenshot ("At ImageCell Table Gallery");
+
+ App.ScrollForElement ("* marked:'Detail 12'", new Drag (ScreenBounds, Drag.Direction.BottomToTop, Drag.DragLength.Medium));
+
+ App.WaitForElement (q => q.Marked ("Detail 12"), "Timeout : Detail 12");
+
+ App.Screenshot ("All ImageCells are present");
+
+ var numberOfImages = App.Query (q => q.Raw (PlatformViews.Image)).Length;
+ // Check that there are images present. In Android,
+ // have to make sure that there are more than 2 for navigation.
+ Assert.IsTrue (numberOfImages > 2);
+
+ App.Screenshot ("Images are present");
+ }
+
+ [Test]
+ [Description ("ListView with SwitchCells, all are present")]
+ [UiTest (typeof(ListView))]
+ [UiTest (typeof(SwitchCell))]
+ public void CellsGallerySwitchCellList ()
+ {
+ App.ScrollForElement ("* marked:'SwitchCell List'", new Drag (ScreenBounds, Drag.Direction.BottomToTop, Drag.DragLength.Medium));
+
+ App.Tap (q => q.Marked ("SwitchCell List"));
+ App.WaitForElement (q => q.Marked ("Label 0"), "Timeout : Label 0");
+
+ App.Screenshot ("At SwitchCell List Gallery");
+
+ App.ScrollForElement ("* marked:'Label 99'", new Drag (ScreenBounds, Drag.Direction.BottomToTop, Drag.DragLength.Medium));
+
+ var numberOfSwitches = App.Query (q => q.Raw (PlatformViews.Switch)).Length;
+ Assert.IsTrue (numberOfSwitches > 2);
+
+ App.Screenshot ("Switches are present");
+ }
+
+ [Test]
+ [Description ("TableView with SwitchCells, all are present")]
+ [UiTest (typeof(TableView))]
+ [UiTest (typeof(SwitchCell))]
+ public void CellsGallerySwitchCellTable ()
+ {
+ App.ScrollForElement ("* marked:'SwitchCell Table'", new Drag (ScreenBounds, Drag.Direction.BottomToTop, Drag.DragLength.Medium));
+
+ App.Tap (q => q.Marked ("SwitchCell Table"));
+ App.WaitForElement (q => q.Marked ("text 1"), "Timeout : text 1");
+
+ App.Screenshot ("At SwitchCell Table Gallery");
+
+ App.ScrollForElement ("* marked:'text 32'", new Drag (ScreenBounds, Drag.Direction.BottomToTop, Drag.DragLength.Medium));
+
+ var numberOfSwitches = App.Query (q => q.Raw (PlatformViews.Switch)).Length;
+ Assert.IsTrue (numberOfSwitches > 2);
+
+ App.Screenshot ("Switches are present");
+ }
+
+ [Test]
+ [Description ("ListView with EntryCells, all are present")]
+ [UiTest (typeof(ListView))]
+ [UiTest (typeof(EntryCell))]
+ public void CellsGalleryEntryCellList ()
+ {
+ App.ScrollForElement ("* marked:'EntryCell List'", new Drag (ScreenBounds, Drag.Direction.BottomToTop, Drag.DragLength.Medium));
+
+ App.Tap (q => q.Marked ("EntryCell List"));
+ App.WaitForElement (q => q.Marked ("Label 0"), "Timeout : Label 0");
+
+ App.Screenshot ("At EntryCell List Gallery");
+
+ App.ScrollForElement ("* marked:'Label 99'", new Drag (ScreenBounds, Drag.Direction.BottomToTop, Drag.DragLength.Medium));
+
+ App.Screenshot ("All EntryCells are present");
+ }
+
+ [Description ("Entered text stays after scrolled out of view")]
+ [Issue (IssueTracker.Github, 1024, "EntryCell with text set clears after scrolling off screen", PlatformAffected.Android)]
+ [UiTest (typeof(EntryCell))]
+ public void CellsGalleryIssue1024 ()
+ {
+ // TODO fix
+// App.ScrollForElement ("* marked:'EntryCell List'", new Drag (ScreenBounds, Drag.Direction.BottomToTop, Drag.DragLength.Medium));
+//
+// App.Tap (q => q.Marked ("EntryCell List"));
+// App.WaitForElement (q => q.Marked ("Label 0"), "Timeout : Label 0");
+// App.Screenshot ("At EntryCell List Gallery");
+//
+// App.Tap (Queries.EntryCellWithPlaceholder ("Placeholder 1"));
+// App.EnterText (Queries.EntryCellWithPlaceholder ("Placeholder 1"), "I am going to be scrolled off screen");
+//
+// App.Screenshot ("Dismiss keyboard");
+//
+// App.ScrollForElement ("* marked:'Label 40'", new Drag (ScreenBounds, Drag.Direction.BottomToTop, Drag.DragLength.Medium));
+// App.Screenshot ("Scroll down");
+//
+// App.ScrollForElement ("* marked:'Label 0'", new Drag (ScreenBounds, Drag.Direction.TopToBottom, Drag.DragLength.Medium));
+//
+// App.WaitForElement (Queries.EntryCellWithText ("I am going to be scrolled off screen"), "Timeout : Scrolled Entry with Text");
+// App.Screenshot ("Scroll back up to cell");
+ }
+
+ [Test]
+ [Description ("TableView with EntryCells, all are present")]
+ [UiTest (typeof(TableView))]
+ [UiTest (typeof(EntryCell))]
+ public void CellsGalleryEntryCellTable ()
+ {
+ App.ScrollForElement ("* marked:'EntryCell Table'", new Drag (ScreenBounds, Drag.Direction.BottomToTop, Drag.DragLength.Medium));
+
+ App.Tap (q => q.Marked ("EntryCell Table"));
+ App.WaitForElement (q => q.Marked ("Text 2"), "Timeout : Text 2");
+
+ App.Screenshot ("At EntryCell Table Gallery");
+
+ App.ScrollForElement ("* marked:'Text 32'", new Drag (ScreenBounds, Drag.Direction.BottomToTop, Drag.DragLength.Medium));
+
+ App.Screenshot ("All EntryCells are present");
+ }
+
+ [Test]
+ [Category ("EntryCell")]
+ [Description ("EntryCell fires .Completed event")]
+ [UiTest (typeof(EntryCell), "Completed")]
+ public void CellsGalleryEntryCellCompleted ()
+ {
+ App.ScrollForElement ("* marked:'EntryCell Table'", new Drag (ScreenBounds, Drag.Direction.BottomToTop, Drag.DragLength.Medium));
+
+ App.Tap (q => q.Marked ("EntryCell Table"));
+ App.WaitForElement (q => q.Marked ("Text 2"), "Timeout : Text 2");
+
+ App.Screenshot ("At EntryCell Table Gallery");
+ App.ScrollForElement ("* marked:'Enter text'", new Drag (ScreenBounds, Drag.Direction.BottomToTop, Drag.DragLength.Medium));
+
+ App.Screenshot ("Before clicking Entry");
+
+ App.Tap (PlatformQueries.EntryCellWithPlaceholder ("I am a placeholder"));
+ App.EnterText (PlatformQueries.EntryCellWithPlaceholder ("I am a placeholder"), "Hi");
+ App.Screenshot ("Entered Text");
+ if (App is AndroidApp) {
+ ((AndroidApp)App).PressUserAction (UserAction.Done);
+ } else {
+ App.PressEnter ();
+ }
+ App.WaitForElement (q => q.Marked ("Entered: 1"));
+ App.Screenshot ("Completed should have changed label's text");
+ }
+
+ //[Test]
+ [Description ("Issue 1033 - page does not respect orientation changes")]
+ public void CellsGalleryIssue1033 ()
+ {
+// App.SetOrientationLandscape ();
+// App.Tap (q => q.Marked ("TextCell List"));
+// App.WaitForElement (q => q.Marked ("Text 2"), "Timeout : Text 2");
+// float listViewHeightLandscape = App.Query (q => q.Raw (Views.ListView))[0].Rect.Height;
+// App.Screenshot ("Landscape list");
+//
+//
+// App.NavigateBack ();
+// App.Screenshot ("Navigate back");
+// App.SetOrientationPortrait ();
+// App.Screenshot ("Set orientation to portrait");
+//
+// App.Tap (q => q.Marked ("TextCell List"));
+// App.WaitForElement (q => q.Marked ("Text 2"), "Timeout : Text 2");
+// float listViewHeightPortrait = App.Query (q => q.Raw (Views.ListView))[0].Rect.Height;
+// App.Screenshot ("Portrait list");
+//
+// // Should be be the same size if the layout is resized
+// Assert.AreNotEqual (listViewHeightLandscape, listViewHeightPortrait);
+ }
+
+ protected override void TestTearDown()
+ {
+ App.NavigateBack ();
+ base.TestTearDown();
+ }
+ }
+}
+
diff --git a/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-ClipToBoundsUITests.cs b/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-ClipToBoundsUITests.cs
new file mode 100644
index 0000000..9dffeaa
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-ClipToBoundsUITests.cs
@@ -0,0 +1,73 @@
+using System;
+using System.Runtime;
+using NUnit.Framework;
+using Xamarin.UITest;
+using Xamarin.UITest.Shared;
+
+namespace Xamarin.Forms.Core.UITests
+{
+ [TestFixture]
+ [Category ("AbsoluteLayout")]
+ internal class ClipToBoundsGalleryTests : BaseTestFixture
+ {
+ // TODO detect size before and after clip
+ // TODO: Port to new conventions
+
+ public ClipToBoundsGalleryTests ()
+ {
+ ShouldResetPerFixture = false;
+ }
+
+ protected override void NavigateToGallery ()
+ {
+ App.NavigateToGallery (GalleryQueries.ClipToBoundsGalleryLegacy);
+ }
+ [Test]
+ [Description ("Check all elements exist")]
+ public void ClipToBoundsGalleryAllElementsExist ()
+ {
+// App.WaitForElement (q => q.Button ("Clip"), "Timeout : Clip");
+// var boxes = App.Query (PlatformQueries.BoxRendererQuery);
+// Assert.AreEqual (2, boxes.Length);
+// App.Screenshot ("2 boxes exist");
+
+
+ }
+
+// [Test]
+// [Description ("Clip boxes")]
+// public void ClipToBoundsGalleryClipElements ()
+// {
+// App.Tap (q => q.Button ("Clip"));
+// App.Screenshot ("Clip elements");
+// }
+
+///*******************************************************/
+///**************** Landscape tests **********************/
+///*******************************************************/
+
+// [Test]
+// [Description ("Check all elements exist - landscape")]
+// public void ClipToBoundsGalleryAllElementsExistLandscape ()
+// {
+// App.SetOrientationLandscape ();
+// App.Screenshot ("Rotated to Landscape");
+// ClipToBoundsGalleryAllElementsExist ();
+// App.SetOrientationPortrait ();
+// App.Screenshot ("Rotated to Portrait");
+// }
+
+// [Test]
+// [Description ("Clip boxes - landscape")]
+// public void ClipToBoundsGalleryClipElementsLandscape ()
+// {
+// App.SetOrientationLandscape ();
+// App.Screenshot ("Rotated to Landscape");
+// ClipToBoundsGalleryClipElements ();
+// App.SetOrientationPortrait ();
+// App.Screenshot ("Rotated to Portrait");
+ // }
+
+ }
+}
+
diff --git a/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-EditorUITests.cs b/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-EditorUITests.cs
new file mode 100644
index 0000000..df34dee
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-EditorUITests.cs
@@ -0,0 +1,269 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using NUnit.Framework;
+using System.Threading;
+
+using Xamarin.Forms.CustomAttributes;
+
+namespace Xamarin.Forms.Core.UITests
+{
+ [TestFixture]
+ [Category ("Editor")]
+ internal class EditorGalleryTests : BaseTestFixture
+ {
+ // TODO: Port to new conventions
+
+ public EditorGalleryTests ()
+ {
+ ShouldResetPerFixture = false;
+ }
+
+ protected override void NavigateToGallery ()
+ {
+ App.NavigateToGallery (GalleryQueries.EditorGalleryLegacy);
+ }
+
+ [Test]
+ [Category ("ManualReview")]
+ [Description ("Try Default keyboard")]
+ [UiTest (typeof (Editor), "Keyboard")]
+ [UiTest (typeof (Keyboard), "Default")]
+ public void EditorGalleryDefaultKeyboardGallery ()
+ {
+// App.Tap (q => q.Marked ("Default Keyboard"));
+// App.WaitForElement (PlatformQueries.Editors, "Timeout : Editors");
+// App.Screenshot ("At Default Keyboard Gallery");
+
+// App.Tap (PlatformQueries.Editors);
+// // App.KeyboardIsPresent ();
+// App.Screenshot ("Keyboard showing");
+
+// var text = "This is some text that I am entering";
+// App.EnterText (PlatformQueries.Editors, text);
+// App.WaitForElement (PlatformQueries.EditorsWithText (text), "Timeout : Editor with Text " + text);
+// App.Screenshot ("Text Entered");
+
+// App.PressEnter ();
+// // App.KeyboardIsDismissed ();
+// App.Screenshot ("Pressed enter");
+ }
+
+// [Test]
+// [Category ("ManualReview")]
+// [Description ("Editor.Completed Fires")]
+// [UiTest (Test.Views.Editor)]
+// [UiTest (Test.Editor.Completed)]
+// public void EditorGalleryDefaultKeyboardGalleryCompletedFires ()
+// {
+// App.Tap (q => q.Marked ("Default Keyboard"));
+// App.WaitForElement (PlatformQueries.Editors, "Timeout : Editors");
+// App.Screenshot ("At Default Keyboard Gallery");
+
+// App.Tap (PlatformQueries.Editors);
+// // App.KeyboardIsPresent ();
+// App.Screenshot ("Keyboard showing");
+// App.EnterText (PlatformQueries.Editors, "First Line");
+// App.PressEnter ();
+
+// App.Screenshot ("Pressed enter");
+// App.EnterText (PlatformQueries.Editors, "Second Line");
+// App.Screenshot ("Entered second line");
+// App.Tap (PlatformQueries.LabelWithText("Nothing entered"));
+// App.Screenshot ("Keyboard dismissed");
+//// App.Tap (q => q.Marked ("Done"));
+
+
+// App.WaitForNoElement (q => q.Marked ("Nothing entered"));
+// App.Screenshot ("Test complete");
+//// App.WaitForElement (q => q.Marked ("Entered : First Line Second Line"));
+// }
+
+// [Test]
+// [Category ("ManualReview")]
+// [Description ("Try Chat keyboard")]
+// [UiTest (Test.Views.Editor)]
+// [UiTest (Test.InputView.Keyboard)]
+// [UiTest (Test.Keyboard.Chat)]
+// public void EditorGalleryChatKeyboardGallery ()
+// {
+// App.Tap (q => q.Marked ("Chat Keyboard"));
+// App.WaitForElement (PlatformQueries.Editors, "Timeout : Editors");
+// App.Screenshot ("At Chat Keyboard Gallery");
+
+// App.Tap (PlatformQueries.Editors);
+// // App.KeyboardIsPresent ();
+// App.Screenshot ("Keyboard showing");
+
+// var text = "This is some text that I am entering";
+// App.EnterText (PlatformQueries.Editors, text);
+// App.WaitForElement (PlatformQueries.EditorsWithText (text), "Timeout : Editor with Text " + text);
+// App.Screenshot ("Text Entered");
+
+// App.PressEnter ();
+// // App.KeyboardIsDismissed ();
+// App.Screenshot ("Pressed enter");
+// }
+
+// [Test]
+// [Category ("ManualReview")]
+// [Description ("Try Text keyboard")]
+// [UiTest (Test.Views.Editor)]
+// [UiTest (Test.InputView.Keyboard)]
+// [UiTest (Test.Keyboard.Text)]
+// public void EditorGalleryTextKeyboardGallery ()
+// {
+// App.Tap (q => q.Marked ("Text Keyboard"));
+// App.WaitForElement (PlatformQueries.Editors, "Timeout : Editors");
+// App.Screenshot ("At Text Keyboard Gallery");
+
+// App.Tap (PlatformQueries.Editors);
+// // App.KeyboardIsPresent ();
+// App.Screenshot ("Keyboard showing");
+
+// var text = "This is some text that I am entering";
+// App.EnterText (PlatformQueries.Editors, text);
+// App.WaitForElement (PlatformQueries.EditorsWithText (text), "Timeout : Editor with Text " + text);
+// App.Screenshot ("Text Entered");
+
+// App.PressEnter ();
+// // App.KeyboardIsDismissed ();
+// App.Screenshot ("Pressed enter");
+// }
+
+// [Test]
+// [Category ("ManualReview")]
+// [Description ("Try Url keyboard")]
+// [UiTest (Test.Views.Editor)]
+// [UiTest (Test.InputView.Keyboard)]
+// [UiTest (Test.Keyboard.Url)]
+// public void EditorGalleryUrlKeyboardGallery ()
+// {
+// App.Tap (q => q.Marked ("Url Keyboard"));
+// App.WaitForElement (PlatformQueries.Editors, "Timeout : Editors");
+// App.Screenshot ("At Url Keyboard Gallery");
+
+// App.Tap (PlatformQueries.Editors);
+// // App.KeyboardIsPresent ();
+// App.Screenshot ("Keyboard showing");
+
+// var text = "https://www.xamarin.com";
+// App.EnterText (PlatformQueries.Editors, text);
+// App.WaitForElement (PlatformQueries.EditorsWithText (text), "Timeout : Editor with Text " + text);
+// App.Screenshot ("Text Entered");
+
+// App.PressEnter ();
+// // App.KeyboardIsDismissed ();
+// App.Screenshot ("Pressed enter");
+// }
+
+// [Test]
+// [Category ("ManualReview")]
+// [Description ("Try Numeric keyboard")]
+// [UiTest (Test.Views.Editor)]
+// [UiTest (Test.InputView.Keyboard)]
+// [UiTest (Test.Keyboard.Numeric)]
+// public void EditorGalleryNumericKeyboardGallery ()
+// {
+// App.Tap (q => q.Marked ("Numeric Keyboard"));
+// App.WaitForElement (PlatformQueries.Editors, "Timeout : Editors");
+// App.Screenshot ("At Numeric Keyboard Gallery");
+
+// App.Tap (PlatformQueries.Editors);
+// // App.KeyboardIsPresent ();
+// App.Screenshot ("Keyboard showing");
+
+// var text = "12345678910";
+// App.EnterText (PlatformQueries.Editors, text);
+// App.WaitForElement (PlatformQueries.EditorsWithText (text), "Timeout : Editor with Text " + text);
+// App.Screenshot ("Text Entered");
+// }
+
+// [Test]
+// [Description ("TextChanged event")]
+// [UiTest (Test.Views.Editor)]
+// [UiTest (Test.Editor.TextChanged)]
+// public void EditorGalleryDefaultKeyboardTextChanged ()
+// {
+// App.Tap (q => q.Marked ("Default Keyboard"));
+// App.WaitForElement (PlatformQueries.Editors, "Timeout : Editors");
+// App.Screenshot ("At Default Keyboard Gallery");
+
+// App.EnterText (PlatformQueries.Editors, "ABC");
+// App.Screenshot ("Entered three characters");
+// App.WaitForElement (PlatformQueries.LabelWithText ("xxx"));
+// var labelText = App.GetTextForQuery (PlatformQueries.LabelWithIndex (1));
+// Assert.AreEqual ("xxx", labelText);
+// }
+
+// [Test]
+// [Description ("TextChanged event - Issue #")]
+// [UiTest (Test.Views.Editor)]
+// [UiTest (Test.Editor.TextChanged)]
+// public void EditorGalleryChatKeyboardTextChanged ()
+// {
+// App.Tap (q => q.Marked ("Chat Keyboard"));
+// App.WaitForElement (PlatformQueries.Editors, "Timeout : Editors");
+// App.Screenshot ("At Chat Keyboard Gallery");
+
+// App.EnterText (PlatformQueries.Editors, "ABC");
+// App.Screenshot ("Entered three characters");
+// App.WaitForElement (PlatformQueries.LabelWithText ("xxx"));
+// var labelText = App.GetTextForQuery (PlatformQueries.LabelWithIndex (1));
+// Assert.AreEqual ("xxx", labelText);
+// }
+
+// [Test]
+// [Description ("TextChanged event")]
+// [UiTest (Test.Views.Editor)]
+// [UiTest (Test.Editor.TextChanged)]
+// public void EditorGalleryNumericKeyboardTextChanged ()
+// {
+// App.Tap (q => q.Marked ("Numeric Keyboard"));
+// App.WaitForElement (PlatformQueries.Editors, "Timeout : Editors");
+// App.Screenshot ("At Numeric Keyboard Gallery");
+
+// App.EnterText (PlatformQueries.Editors, "123");
+// App.Screenshot ("Entered three characters");
+// App.WaitForElement (PlatformQueries.LabelWithText ("xxx"));
+// var labelText = App.GetTextForQuery (PlatformQueries.LabelWithIndex (1));
+// Assert.AreEqual ("xxx", labelText);
+// }
+
+// [Test]
+// [Description ("TextChanged event")]
+// [UiTest (Test.Views.Editor)]
+// [UiTest (Test.Editor.TextChanged)]
+// public void EditorGalleryTextKeyboardTextChanged ()
+// {
+// App.Tap (q => q.Marked ("Text Keyboard"));
+// App.WaitForElement (PlatformQueries.Editors, "Timeout : Editors");
+// App.Screenshot ("At Text Keyboard Gallery");
+
+// App.EnterText (PlatformQueries.Editors, "ABC");
+// App.Screenshot ("Entered three characters");
+// App.WaitForElement (PlatformQueries.LabelWithText ("xxx"));
+// var labelText = App.GetTextForQuery (PlatformQueries.LabelWithIndex (1));
+// Assert.AreEqual ("xxx", labelText);
+// }
+
+// [Test]
+// [Description ("TextChanged event")]
+// [UiTest (Test.Views.Editor)]
+// [UiTest (Test.Editor.TextChanged)]
+// public void EditorGalleryUrlKeyboardTextChanged ()
+// {
+// App.Tap (q => q.Marked ("Url Keyboard"));
+// App.WaitForElement (PlatformQueries.Editors, "Timeout : Editors");
+// App.Screenshot ("At Url Keyboard Gallery");
+
+// App.EnterText (PlatformQueries.Editors, "ABC");
+// App.Screenshot ("Entered three characters");
+// App.WaitForElement (PlatformQueries.LabelWithText ("xxx"));
+// var labelText = App.GetTextForQuery (PlatformQueries.LabelWithIndex (1));
+// Assert.AreEqual ("xxx", labelText);
+// }
+ }
+}
diff --git a/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-EntryUITests.cs b/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-EntryUITests.cs
new file mode 100644
index 0000000..e88ff6b
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-EntryUITests.cs
@@ -0,0 +1,301 @@
+using System;
+using NUnit.Framework;
+using System.Collections.Generic;
+using Xamarin.UITest.Queries;
+
+namespace Xamarin.Forms.Core.UITests
+{
+ [TestFixture]
+ [Category ("Entry")]
+ internal class EntryGalleryTests : BaseTestFixture
+ {
+ // TODO: Get Toggle color tests for both iOS and Android, Keyboard dismisses for Enter
+ // TODO: Port to new conventions
+
+ public EntryGalleryTests ()
+ {
+ ShouldResetPerFixture = false;
+ }
+
+ protected override void NavigateToGallery ()
+ {
+ App.NavigateToGallery (GalleryQueries.EntryGalleryLegacy);
+ }
+ [Test]
+ [Description ("All Entry Gallery elements are present")]
+ public void EntryGalleryAllElementsPresent ()
+ {
+
+// var entryElements = new [] {
+// q => q.Marked ("Enter something in Normal"),
+// q => q.Marked ("No typing has happened in Normal yet"),
+// PlatformQueries.EntryWithPlaceholder ("Normal"),
+// PlatformQueries.EntryWithPlaceholder ("Password"),
+// PlatformQueries.EntryWithPlaceholder ("Numeric Password"),
+// q => q.Marked ("Focus an Entry"),
+// PlatformQueries.EntryWithPlaceholder ("Disabled"),
+// PlatformQueries.EntryWithPlaceholder ("Activation"),
+// PlatformQueries.EntryWithPlaceholder ("Transparent"),
+// PlatformQueries.EntryWithPlaceholder ("Keyboard.Default")
+// };
+
+// foreach (var entry in entryElements)
+// App.ScrollDownForElement (entry, 10);
+
+// var buttons = new [] {
+// "Toggle Text Color",
+// "Toggle Secure",
+// "Change Placeholder",
+// "Focus First"
+// };
+
+// foreach (var button in buttons)
+// App.ScrollDownForElement (q => q.Button (button), 10);
+
+// App.Screenshot ("All elements present");
+ }
+
+// [Test]
+// [Category ("ManualReview")]
+// [Description ("Check that the keyboard shows for each Entry")]
+// public void EntryGalleryKeyboardDisplays ()
+// {
+// AppRect windowBounds = App.MainScreenBounds ();
+
+// var placeHolders = new [] {
+// "Normal",
+// "Password",
+// "Numeric Password",
+// "Disabled",
+// "Activation",
+// "Transparent",
+// "Keyboard.Default"
+// };
+
+// foreach (var placeholder in placeHolders) {
+// App.ScrollDownForElement (PlatformQueries.EntryWithPlaceholder (placeholder), 3);
+// if (placeholder != "Disabled") {
+// App.Tap (PlatformQueries.EntryWithPlaceholder (placeholder));
+// //App.KeyboardIsPresent ();
+// App.Screenshot ("Keyboard shown: " + placeholder);
+// // Tap empty part of screen
+// App.TapCoordinates (10, windowBounds.Height / 3);
+// } else { // Disabled entry should not show keyboard
+// App.Tap (PlatformQueries.EntryWithPlaceholder (placeholder));
+// //App.KeyboardIsDismissed ();
+// App.Screenshot ("Keyboard not shown: " + placeholder);
+// }
+// }
+
+// App.Screenshot ("Keyboard should be dismissed");
+// }
+
+// [Test]
+// [Category ("ManualReview")]
+// [Description ("Enter text in each entry")]
+// public void EntryGalleryEnterTextInEachFieldAndTapScreenDismiss ()
+// {
+// var entries = new [] {
+// new { Placeholder = "Normal", LabelValue = "Normal Focused" },
+// new { Placeholder = "Password", LabelValue = "Password Focused" },
+// new { Placeholder = "Numeric Password", LabelValue = "Numeric Password Focused" },
+// new { Placeholder = "Disabled", LabelValue = "Disabled Focused" },
+// new { Placeholder = "Activation", LabelValue = "Activation Focused" },
+// new { Placeholder = "Transparent", LabelValue = "Transparent Focused" },
+// new { Placeholder = "Keyboard.Default", LabelValue = "Keyboard.Default Focused" },
+// };
+
+// AppRect windowBounds = App.MainScreenBounds ();
+// int helloNum = 0;
+
+// foreach (var entry in entries) {
+// App.ScrollDownForElement (PlatformQueries.EntryWithPlaceholder (entry.Placeholder), 3);
+// if (entry.Placeholder == "Disabled") {
+// App.Tap (PlatformQueries.EntryWithPlaceholder (entry.Placeholder));
+// // App.KeyboardIsDismissed ();
+// } else if (entry.Placeholder == "Numeric Password") {
+// App.Tap (PlatformQueries.EntryWithPlaceholder (entry.Placeholder));
+// // App.KeyboardIsPresent ();
+// App.EnterText (PlatformQueries.EntryWithPlaceholder (entry.Placeholder), "167728");
+// App.TapCoordinates (10, windowBounds.Height / 3);
+// } else {
+// App.Tap (PlatformQueries.EntryWithPlaceholder (entry.Placeholder));
+// // App.KeyboardIsPresent ();
+// App.EnterText (PlatformQueries.EntryWithPlaceholder (entry.Placeholder), "Hello " + helloNum);
+// App.TapCoordinates (10, windowBounds.Height / 3);
+// helloNum++;
+// }
+// }
+
+// App.Screenshot ("Entered text in each entry, password should be hidden");
+// App.Tap (q => q.Button ("Toggle Secure"));
+
+// App.ScrollUpForElement (q => q.Marked ("Hello 0"), 5);
+// App.ScrollDownForElement (q => q.Marked ("Hello 1"), 5);
+// App.ScrollDownForElement (q => q.Marked ("167728"), 5);
+// App.ScrollDownForElement (q => q.Marked ("Hello 3"), 5);
+// App.ScrollDownForElement (q => q.Marked ("Hello 4"), 5);
+// App.ScrollDownForElement (q => q.Marked ("Hello 5"), 5);
+
+// App.Screenshot ("Entered text in each entry, password should be shown");
+// }
+
+//// [Test]
+//// public void ToggleTextColor ()
+//// {
+//// AllElementsPresent ();
+////
+//// var text = "hello";
+//// App.EnterText (PlatformQueries.EntryWithPlaceholder ("Normal"), text);
+//// var initialTextColor = App.Query (q => q.Raw (string.Format ("{0} {1}:'{2}', :getCurrentTextColor", PlatformStrings.Entry, PlatformStrings.Text, text)));
+//// App.Tap (q => q.Button ("Toggle Text Color"));
+//// var secondTextColor = App.Query (q => q.Raw (string.Format ("{0} {1}:'{2}', :getCurrentTextColor", PlatformStrings.Entry, PlatformStrings.Text, text)));
+//// Assert.AreNotEqual (initialTextColor, secondTextColor);
+//// }
+
+// [Test]
+// [Description ("Change Placeholder in each entry")]
+// public void EntryGalleryChangePlaceholder ()
+// {
+// for (var i = 1; i <= 5; i++) {
+// App.ScrollDownForElement (q => q.Button ("Change Placeholder"), 5);
+// App.Tap (q => q.Button ("Change Placeholder"));
+// App.ScrollUpForElement (PlatformQueries.EntryWithPlaceholder ("Placeholder " + i), 5);
+// }
+
+// App.Screenshot ("Changed placeholder 5 times");
+// }
+
+// [Test]
+// [Category ("ManualReview")]
+// [Description ("Update Keyboard Type - #1307")]
+// public void EntryGalleryChangeKeyboardType ()
+// {
+// App.ScrollDownForElement (PlatformQueries.EntryWithPlaceholder ("Keyboard.Default"), 5);
+// App.Tap (PlatformQueries.EntryWithPlaceholder ("Keyboard.Default"));
+// App.Screenshot ("I should see the default keyboard");
+// App.PressEnter ();
+// App.Screenshot ("Keyboard should be dismissed");
+// App.Screenshot ("Manually check that keyboard type is switched");
+//// App.WaitForElement (PlatformQueries.EntryWithPlaceholder ("Keyboard.Numeric"));
+//// App.Tap (PlatformQueries.EntryWithPlaceholder ("Keyboard.Numeric"));
+// App.Screenshot ("I should see the numeric keyboard");
+// }
+
+// [Test]
+// [Category ("ManualReview")]
+// [Description ("Completed handler firing, keyboard dismissing - #1308")]
+// public void EntryGalleryCheckCompletedKeyboardDismissed ()
+// {
+// App.WaitForElement (q => q.Marked ("Enter something in Normal"));
+// App.ScrollDownForElement (PlatformQueries.EntryWithPlaceholder ("Normal"), 5);
+// App.Tap (PlatformQueries.EntryWithPlaceholder ("Normal"));
+// App.Screenshot ("Tapped Normal");
+// App.EnterText (PlatformQueries.EntryWithPlaceholder ("Normal"), "It has been entered");
+// App.Screenshot ("The keyboard should be shown");
+// // App.PressEnter ();
+// App.Screenshot ("Keyboard should be dismissed - Check manually");
+// //App.WaitForNoElement (q => q.Marked ("Enter something in Normal"));
+// //App.ScrollUpForElement (q => q.Marked ("It has been entered"), 5);
+// App.Screenshot ("Text should have changed");
+// }
+
+// [Test]
+// [Description ("Test the TextChanged event")]
+// public void EntryGalleryTextChangedEventTest ()
+// {
+// App.Screenshot ("Waiting for entry gallery");
+// App.WaitForElement (q => q.Marked ("No typing has happened in Normal yet"));
+// App.Screenshot ("Entering text in Normal");
+// App.EnterText (PlatformQueries.EntryWithPlaceholder ("Normal"), "a");
+// App.WaitForElement (q => q.Marked ("You typed in normal"));
+// App.Screenshot ("Text entered, TextChanged event should have fired");
+// }
+
+
+///*******************************************************/
+///**************** Landscape tests **********************/
+///*******************************************************/
+
+// [Test]
+// [Description ("All Entry Gallery elements are present - landscape")]
+// public void EntryGalleryAllElementsPresentLandscape ()
+// {
+// App.SetOrientationLandscape ();
+// App.Screenshot ("Rotated to Landscape");
+// EntryGalleryAllElementsPresent ();
+// App.SetOrientationPortrait ();
+// App.Screenshot ("Rotated to Portrait");
+// }
+
+// [Test]
+// [Category ("ManualReview")]
+// [Description ("Check that the keyboard shows for each Entry - landscape")]
+// public void EntryGalleryKeyboardDisplaysLandscape ()
+// {
+// App.SetOrientationLandscape ();
+// App.Screenshot ("Rotated to Landscape");
+// EntryGalleryKeyboardDisplays ();
+// App.SetOrientationPortrait ();
+// App.Screenshot ("Rotated to Portrait");
+// }
+
+// [Test]
+// [Category ("ManualReview")]
+// [Description ("Enter text in each entry - landscape")]
+// public void EntryGalleryEnterTextInEachFieldAndTapScreenDismissLandscape ()
+// {
+// App.SetOrientationLandscape ();
+// App.Screenshot ("Rotated to Landscape");
+// EntryGalleryEnterTextInEachFieldAndTapScreenDismiss ();
+// App.SetOrientationPortrait ();
+// App.Screenshot ("Rotated to Portrait");
+// }
+
+// [Test]
+// [Description ("Change Placeholder in each entry - landscape")]
+// public void EntryGalleryChangePlaceholderLandscape ()
+// {
+// App.SetOrientationLandscape ();
+// App.Screenshot ("Rotated to Landscape");
+// EntryGalleryChangePlaceholder ();
+// App.SetOrientationPortrait ();
+// App.Screenshot ("Rotated to Portrait");
+// }
+
+// [Test]
+// [Category ("ManualReview")]
+// [Description ("Update Keyboard Type - #1307 - Landscape")]
+// public void EntryGalleryChangeKeyboardTypeLandscape ()
+// {
+// App.SetOrientationLandscape ();
+// App.Screenshot ("Rotated to Landscape");
+// EntryGalleryChangeKeyboardType ();
+// App.SetOrientationPortrait ();
+// App.Screenshot ("Rotated to Portrait");
+// }
+
+// [Test]
+// [Description ("Completed handler firing, keyboard dismissing - #1308 - Landscape")]
+// public void EntryGalleryCheckCompletedKeyboardDismissedLandscape ()
+// {
+// App.SetOrientationLandscape ();
+// App.Screenshot ("Rotated to Landscape");
+// EntryGalleryCheckCompletedKeyboardDismissed ();
+// App.SetOrientationPortrait ();
+// App.Screenshot ("Rotated to Portrait");
+// }
+
+// [Test]
+// [Description ("Test the TextChanged event - Landscape")]
+// public void EntryGalleryTextChangedEventTestLandscape ()
+// {
+// App.SetOrientationLandscape ();
+// App.Screenshot ("Rotated to Landscape");
+// EntryGalleryTextChangedEventTest ();
+// App.SetOrientationPortrait ();
+// App.Screenshot ("Rotated to Portrait");
+// }
+
+ }
+}
diff --git a/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-GridGalleryUITests.cs b/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-GridGalleryUITests.cs
new file mode 100644
index 0000000..04b5946
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-GridGalleryUITests.cs
@@ -0,0 +1,132 @@
+using NUnit.Framework;
+
+using Xamarin.Forms.CustomAttributes;
+using Xamarin.UITest;
+using Xamarin.UITest.Queries;
+using System.Threading;
+
+namespace Xamarin.Forms.Core.UITests
+{
+ [TestFixture]
+ [Category ("GridLayout")]
+ internal class GridLayoutGalleryTests : BaseTestFixture
+ {
+ // TODO - test Absolutes
+ // TODO: Port to new conventions
+
+ public GridLayoutGalleryTests ()
+ {
+ ShouldResetPerFixture = false;
+ }
+
+ protected override void NavigateToGallery ()
+ {
+ App.NavigateToGallery (GalleryQueries.GridGalleryLegacy);
+ }
+
+ //void AllElementsPresent ()
+ //{
+ // App.ScrollForElement ("* marked:'Column Types:'", new Drag (ScreenBounds, Drag.Direction.BottomToTop, Drag.DragLength.Medium));
+ // App.ScrollForElement ("* marked:'Absolute Width'", new Drag (ScreenBounds, Drag.Direction.BottomToTop, Drag.DragLength.Medium));
+ // App.ScrollForElement ("* marked:'Auto Width'", new Drag (ScreenBounds, Drag.Direction.BottomToTop, Drag.DragLength.Medium));
+ // App.ScrollForElement ("* marked:'Star'", new Drag (ScreenBounds, Drag.Direction.BottomToTop, Drag.DragLength.Medium));
+ // App.ScrollForElement ("* marked:'*'", new Drag (ScreenBounds, Drag.Direction.BottomToTop, Drag.DragLength.Medium));
+ // App.ScrollForElement ("* marked:'**'", new Drag (ScreenBounds, Drag.Direction.BottomToTop, Drag.DragLength.Medium));
+ // App.ScrollForElement ("* marked:'***'", new Drag (ScreenBounds, Drag.Direction.BottomToTop, Drag.DragLength.Medium));
+ // App.ScrollForElement ("* marked:'Right'", new Drag (ScreenBounds, Drag.Direction.BottomToTop, Drag.DragLength.Medium));
+ // App.ScrollForElement ("* marked:'Center'", new Drag (ScreenBounds, Drag.Direction.BottomToTop, Drag.DragLength.Medium));
+ // App.ScrollForElement ("* marked:'Left'", new Drag (ScreenBounds, Drag.Direction.BottomToTop, Drag.DragLength.Medium));
+ // App.ScrollForElement ("* marked:'Fill'", new Drag (ScreenBounds, Drag.Direction.BottomToTop, Drag.DragLength.Medium));
+ // App.ScrollForElement ("* marked:'Spans:'", new Drag (ScreenBounds, Drag.Direction.BottomToTop, Drag.DragLength.Medium));
+ // App.ScrollForElement ("* marked:'Spanning 4 columns'", new Drag (ScreenBounds, Drag.Direction.BottomToTop, Drag.DragLength.Medium));
+ // App.ScrollForElement ("* marked:'Spanning 3 rows'", new Drag (ScreenBounds, Drag.Direction.BottomToTop, Drag.DragLength.Medium));
+ // App.ScrollForElement ("* marked:'Spanning 4 columns'", new Drag (ScreenBounds, Drag.Direction.BottomToTop, Drag.DragLength.Medium));
+ // App.ScrollForElement ("* marked:'a block 3x3'", new Drag (ScreenBounds, Drag.Direction.BottomToTop, Drag.DragLength.Medium));
+
+ // App.Screenshot ("All elements present");
+ //}
+
+
+ [Test]
+ [Category("ManualReview")]
+ [Description ("Check Grid Star sizing")]
+ [UiTest (typeof(Grid))]
+ public void GridLayoutGalleryStarLayout ()
+ {
+ // AllElementsPresent ();
+
+ // App.ScrollForElement ("* marked:'*'", new Drag (ScreenBounds, Drag.Direction.TopToBottom, Drag.DragLength.Medium));
+
+ // var oneStarWidth = App.Query (q => q.Marked ("*"))[0].Rect.Width;
+ // var twoStarWidth = App.Query (q => q.Marked ("**"))[0].Rect.Width;
+ // var threeStarWidth = App.Query (q => q.Marked ("***"))[0].Rect.Width;
+
+ // Assert.AreEqual (threeStarWidth, oneStarWidth * 3, 2.0);
+ // Assert.AreEqual (twoStarWidth, oneStarWidth * 2, 2.0);
+
+ // App.Screenshot ("Star layout correct");
+ }
+
+ // TODO port to new framework
+ //[Test]
+ //[UiTest (Test.Layouts.Grid)]
+ //public void GridLayoutGallerySpanSizes ()
+ //{
+ // AllElementsPresent ();
+
+ // var unitWidth = App.Query (q => q.Marked ("Unit"))[0].Rect.Width;
+ // var unitHeight = App.Query (q => q.Marked ("Unit"))[0].Rect.Height;
+
+ // var spanningFourColumnsWidth = App.Query (q => q.Marked ("Spanning 4 columns"))[0].Rect.Width;
+ // var spanningFourColumnsHeight = App.Query (q => q.Marked ("Spanning 4 columns"))[0].Rect.Height;
+
+ // // platform queries deal with label rendering differences
+ // var threeXThreeWidth = App.Query (PlatformQueries.ThreeXThreeGridCell) [0].Rect.Width;
+ // var threeXThreeHeight = App.Query (PlatformQueries.ThreeXThreeGridCell) [0].Rect.Height;
+
+ // var spanningThreeRowsWidth = App.Query (PlatformQueries.SpanningThreeRows)[0].Rect.Width;
+ // var spanningThreeRowsHeight = App.Query (PlatformQueries.SpanningThreeRows)[0].Rect.Height;
+
+ // Assert.AreEqual (spanningFourColumnsWidth, unitWidth * 4, 2.0);
+ // Assert.AreEqual (spanningFourColumnsHeight, unitHeight, 2.0);
+
+ // Assert.AreEqual (threeXThreeWidth, unitWidth * 3, 2.0);
+ // Assert.AreEqual (threeXThreeHeight, unitHeight * 3, 2.0);
+
+ // Assert.AreEqual (spanningThreeRowsWidth, unitWidth, 2.0);
+ // Assert.AreEqual (spanningThreeRowsHeight, unitHeight * 3, 2.0);
+
+ // App.Screenshot ("Span sizes correct");
+ //}
+
+ // TODO port to new framework
+ //[Test]
+ //[UiTest (Test.Layouts.Grid)]
+ //public void GridLayoutGalleryResizesProperlyAfterRotation ()
+ //{
+ // // Displays GridLayout bug on rotation (Issue #854)
+ // AllElementsPresent ();
+
+ // AppRect detailBounds = App.DetailPage ().Rect;
+
+ // var oneStarWidth = App.Query (q => q.Marked ("*"))[0].Rect.Width;
+ // var twoStarWidth = App.Query (q => q.Marked ("**"))[0].Rect.Width;
+ // var threeStarWidth = App.Query (q => q.Marked ("***"))[0].Rect.Width;
+
+ // Assert.AreEqual (detailBounds.Width, oneStarWidth + twoStarWidth + threeStarWidth, 1.0);
+ // App.Screenshot ("All stars fill portrait screen width");
+
+ // App.SetOrientationLandscape ();
+
+ // AppRect detailBoundsAfterRotation = App.DetailPage ().Rect;
+ // var oneStarWidthAfterRotation = App.Query (q => q.Marked ("*"))[0].Rect.Width;
+ // var twoStarWidthAfterRotation = App.Query (q => q.Marked ("**"))[0].Rect.Width;
+ // var threeStarWidthAfterRotation = App.Query (q => q.Marked ("***"))[0].Rect.Width;
+
+ // Assert.AreEqual (detailBoundsAfterRotation.Width, oneStarWidthAfterRotation + twoStarWidthAfterRotation + threeStarWidthAfterRotation, 1.0);
+ // App.Screenshot ("Grid stars resized");
+
+ // App.SetOrientationPortrait ();
+ //}
+ }
+}
diff --git a/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-GroupedListActionsUITests.cs b/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-GroupedListActionsUITests.cs
new file mode 100644
index 0000000..289b538
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-GroupedListActionsUITests.cs
@@ -0,0 +1,277 @@
+using NUnit.Framework;
+using System.Threading;
+
+namespace Xamarin.Forms.Core.UITests
+{
+ [TestFixture]
+ [Category ("ListView")]
+ internal class GroupedListActionsGalleryTests : BaseTestFixture
+ {
+ // TODO Group item actions, isolate specific indices (iOS is by 1, Android by two for cells)
+ // TODO: Port to new conventions
+
+ public GroupedListActionsGalleryTests ()
+ {
+ ShouldResetPerFixture = false;
+ }
+
+ protected override void NavigateToGallery ()
+ {
+ App.NavigateToGallery (GalleryQueries.GroupedListActionsGalleryLegacy);
+ }
+
+ [Test]
+ [Description ("All of the grouped list actions are displayed")]
+ public void GroupedListActionsGalleryAllElementsExist ()
+ {
+// var actions = new [] {
+// "General",
+// "Change group name",
+// "Change group short name",
+// "Child item actions",
+// "Clear this group",
+// "Insert group item",
+// "Insert 2 group items",
+// "Remove next item",
+// "Dummy item RDI",
+// "Remove next 2 dummy items",
+// "Dummy item RmDI-1",
+// "Dummy item RmDI-2",
+// "Replace dummy item",
+// "Dummy item RpDI",
+// "Replace next two dummy items",
+// "Dummy item RpDI-1",
+// "Dummy item RpDI-2",
+// "Select next dummy item",
+// "Dummy item SI",
+// "Move dummy above this one",
+// "Dummy item MDI",
+// "Move last 2 items above this one",
+// "Dummy item M2DI-1",
+// "Dummy item M2DI-2",
+// "Group item actions",
+// "Clear all",
+// "Insert group",
+// "Insert 2 groups",
+// "Remove previous dummy group",
+// "Remove previous 2 dummy groups",
+// "Replace previous dummy group",
+// "Replace previous 2 dummy groups",
+// "Move next group above",
+// "Move next 2 groups above"
+// };
+
+// foreach (var action in actions) {
+// App.ScrollDownForElement (q => q.Marked (action), 40);
+// }
+
+// App.Screenshot ("All actions are preset");
+ }
+
+// [Test]
+// [Description ("Change group name")]
+// public void GroupedListActionsGalleryChangeGroupName ()
+// {
+// App.ScrollDownForElement (q => q.Marked ("General"), 40);
+// App.Screenshot ("Before changing group name");
+// App.Tap (q => q.Marked ("Change group name"));
+// App.WaitForElement (q => q.Marked ("General (changed)"));
+// App.Screenshot ("After changing group name");
+// }
+
+// [Test]
+// [Description ("Child actions - clear group")]
+// public void GroupedListActionsGalleryChildClearGroup ()
+// {
+// App.ScrollDownForElement (q => q.Marked ("Clear this group"), 40);
+// App.Screenshot ("Before clearing group");
+// App.Tap (q => q.Marked ("Clear this group"));
+// App.WaitForNoElement (q => q.Marked ("Insert group item"));
+// App.WaitForNoElement (q => q.Marked ("Insert 2 group items"));
+// App.Screenshot ("After clearing the group");
+// }
+
+// [Test]
+// [Description ("Child actions - insert item(s)")]
+// public void GroupedListActionsGalleryChildInsertItems ()
+// {
+// App.ScrollDownForElement (q => q.Marked ("Insert group item"), 40);
+// App.Screenshot ("Before inserting item");
+
+// App.Tap (q => q.Marked ("Insert group item"));
+// App.ScrollUpForElement (q => q.Marked ("Inserted item S"), 2);
+// App.WaitForElement (q => q.Marked ("Inserted item S"));
+// App.Screenshot ("After inserting item");
+
+// App.ScrollDownForElement (q => q.Marked ("Insert 2 group items"), 2);
+// App.Tap (q => q.Marked ("Insert 2 group items"));
+// App.ScrollUpForElement (q => q.Marked ("Inserted item D 0"), 2);
+// App.WaitForElement (q => q.Marked ("Inserted item D 0"));
+// App.WaitForElement (q => q.Marked ("Inserted item D 1"));
+// App.Screenshot ("After inserting 2 items");
+// }
+
+
+// [Test]
+// [Description ("Child actions - remove item(s)")]
+// public void GroupedListActionsGalleryChildRemoveItems ()
+// {
+// App.ScrollDownForElement (q => q.Marked ("Remove next item"), 40);
+// App.Screenshot ("Before removing item");
+
+// App.Tap (q => q.Marked ("Remove next item"));
+// App.WaitForNoElement (q => q.Marked ("Dummy item RDI"));
+// App.Screenshot ("After removing item");
+
+// App.ScrollDownForElement (q => q.Marked ("Remove next 2 dummy items"), 40);
+// App.Tap (q => q.Marked ("Remove next 2 dummy items"));
+// App.WaitForNoElement (q => q.Marked ("Dummy item RmDI-1"));
+// App.WaitForNoElement (q => q.Marked ("Dummy item RmDI-2"));
+// App.Screenshot ("After removing 2 items");
+// }
+
+// [Test]
+// [Description ("Child actions - replace item(s)")]
+// public void GroupedListActionsGalleryChildReplaceItems ()
+// {
+// App.ScrollDownForElement (q => q.Marked ("Replace dummy item"), 40);
+// App.Screenshot ("Before replacing item");
+
+// App.Tap (q => q.Marked ("Replace dummy item"));
+// App.WaitForNoElement (q => q.Marked ("Dummy item RpDI"));
+// App.ScrollDownForElement (q => q.Marked ("Replaced item"), 2);
+// App.Screenshot ("After replacing item");
+
+// App.ScrollDownForElement (q => q.Marked ("Replace next two dummy items"), 40);
+// App.Tap (q => q.Marked ("Replace next two dummy items"));
+// App.WaitForNoElement (q => q.Marked ("Dummy item RpDI-1"));
+// App.WaitForNoElement (q => q.Marked ("Dummy item RpDI-2"));
+// App.WaitForElement (q => q.Marked ("Replaced items 0"));
+// App.WaitForElement (q => q.Marked ("Replaced items 1"));
+// App.Screenshot ("After replacing 2 items");
+// }
+
+// [Test]
+// [Category ("ManualReview")]
+// [Description ("Child actions - select item(s)")]
+// public void GroupedListActionsGalleryChildSelectItems ()
+// {
+// App.ScrollDownForElement (q => q.Marked ("Select next dummy item"), 40);
+// App.Screenshot ("Before selecting item");
+// App.Tap (q => q.Marked ("Select next dummy item"));
+// App.Screenshot ("After selecting item");
+// }
+
+// [Test]
+// [Category ("ManualReview")]
+// [Description ("Child actions - move item(s)")]
+// public void GroupedListActionsGalleryChildMoveItems ()
+// {
+// App.ScrollDownForElement (q => q.Marked ("Move dummy above this one"), 40);
+// App.Screenshot ("Before moving item");
+
+// App.Tap (q => q.Marked ("Move dummy above this one"));
+// App.Screenshot ("Dummy item MDI should now be above 'Move dummy above this one'");
+
+// App.Tap (q => q.Marked ("Move last 2 items above this one"));
+// App.Screenshot ("Dummy item M2DI-1 and M2DI-2 should now be above 'Move last 2 items above this one'");
+
+// }
+
+///*******************************************************/
+///**************** Landscape tests **********************/
+///*******************************************************/
+
+// [Test]
+// [Description ("Child item action test - landscape")]
+// public void GroupedListActionsGalleryAllElementsExistLandscape ()
+// {
+// App.SetOrientationLandscape ();
+// App.Screenshot ("Rotated to Landscape");
+// GroupedListActionsGalleryAllElementsExist ();
+// App.SetOrientationPortrait ();
+// App.Screenshot ("Rotated to portrait");
+// }
+
+// [Test]
+// [Description ("Change group name - landscape")]
+// public void GroupedListActionsGalleryChangeGroupNameLandscape ()
+// {
+// App.SetOrientationLandscape ();
+// App.Screenshot ("Rotated to Landscape");
+// GroupedListActionsGalleryChangeGroupName ();
+// App.SetOrientationPortrait ();
+// App.Screenshot ("Rotated to portrait");
+// }
+
+// [Test]
+// [Description ("Child actions - clear group - landscape")]
+// public void GroupedListActionsGalleryChildClearGroupLandscape ()
+// {
+// App.SetOrientationLandscape ();
+// App.Screenshot ("Rotated to Landscape");
+// GroupedListActionsGalleryChildClearGroup ();
+// App.SetOrientationPortrait ();
+// App.Screenshot ("Rotated to portrait");
+// }
+
+// [Test]
+// [Description ("Child actions - insert item(s) - landscape")]
+// public void GroupedListActionsGalleryChildInsertItemsLandscape ()
+// {
+// App.SetOrientationLandscape ();
+// App.Screenshot ("Rotated to Landscape");
+// GroupedListActionsGalleryChildInsertItems ();
+// App.SetOrientationPortrait ();
+// App.Screenshot ("Rotated to portrait");
+// }
+
+
+// [Test]
+// [Description ("Child actions - remove item(s) - landscape")]
+// public void GroupedListActionsGalleryChildRemoveItemsLandscape ()
+// {
+// App.SetOrientationLandscape ();
+// App.Screenshot ("Rotated to Landscape");
+// GroupedListActionsGalleryChildRemoveItems ();
+// App.SetOrientationPortrait ();
+// App.Screenshot ("Rotated to portrait");
+// }
+
+// [Test]
+// [Description ("Child actions - replace item(s) - landscape")]
+// public void GroupedListActionsGalleryChildReplaceItemsLandscape ()
+// {
+// App.SetOrientationLandscape ();
+// App.Screenshot ("Rotated to Landscape");
+// GroupedListActionsGalleryChildReplaceItems ();
+// App.SetOrientationPortrait ();
+// App.Screenshot ("Rotated to portrait");
+// }
+
+// [Test]
+// [Category ("ManualReview")]
+// [Description ("Child actions - select item(s) - landscape")]
+// public void GroupedListActionsGalleryChildSelectItemsLandscape ()
+// {
+// App.SetOrientationLandscape ();
+// App.Screenshot ("Rotated to Landscape");
+// GroupedListActionsGalleryChildSelectItems ();
+// App.SetOrientationPortrait ();
+// App.Screenshot ("Rotated to portrait");
+// }
+
+// [Test]
+// [Category ("ManualReview")]
+// [Description ("Child actions - move item(s) - landscape")]
+// public void GroupedListActionsGalleryChildMoveItemsLandscape ()
+// {
+// App.SetOrientationLandscape ();
+// App.Screenshot ("Rotated to Landscape");
+// GroupedListActionsGalleryChildMoveItems ();
+// App.SetOrientationPortrait ();
+// App.Screenshot ("Rotated to portrait");
+// }
+
+ }
+} \ No newline at end of file
diff --git a/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-InputIntentUITests.cs b/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-InputIntentUITests.cs
new file mode 100644
index 0000000..1071308
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-InputIntentUITests.cs
@@ -0,0 +1,190 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using NUnit.Framework;
+using Xamarin.UITest;
+using Xamarin.UITest.Queries;
+
+namespace Xamarin.Forms.Core.UITests
+{
+ [TestFixture]
+ [Category ("Entry")]
+ internal class InputIntentGalleryTests : BaseTestFixture
+ {
+ // TODO: Detect keyboard types, fix scroll coordinates
+ // TODO: Port to new conventions
+
+ public InputIntentGalleryTests ()
+ {
+ ShouldResetPerFixture = false;
+ }
+
+ protected override void NavigateToGallery ()
+ {
+ App.NavigateToGallery (GalleryQueries.InputIntentGalleryLegacy);
+ }
+
+ [Test]
+ [Description ("All entries are shown")]
+ public void InputIntentGalleryAllElementsExist ()
+ {
+// var inputs = new [] {
+// "Default",
+// "Email Input",
+// "Text Input",
+// "Url Input",
+// "Numeric Input",
+// "Telephone Input",
+// "Chat Input",
+// "Custom Entry"
+// };
+
+// foreach (var input in inputs)
+// App.ScrollDownForElement (PlatformQueries.EntryWithPlaceholder (input), 5);
+
+// App.Screenshot ("All Entries exist");
+ }
+
+// [Test]
+// [Description ("Tap each entry and dismiss keyboard by tapping outside of keyboard")]
+// public void InputIntentGalleryTapEachEntry ()
+// {
+// AppRect screenSize = App.MainScreenBounds ();
+// var numberOfEntries = App.Query (PlatformQueries.Entrys).Length;
+// App.Screenshot ("Tap each entry");
+
+// var inputs = new List<string> () {
+// "Default",
+// "Email Input",
+// "Text Input",
+// "Url Input",
+// "Numeric Input",
+// "Telephone Input",
+// "Chat Input",
+// "Custom Entry"
+// };
+
+// foreach (var input in inputs) {
+// App.ScrollDownForElement (PlatformQueries.EntryWithPlaceholder (input), 5);
+// App.Tap (PlatformQueries.EntryWithPlaceholder (input));
+// App.Screenshot ("Input Tapped: " + input);
+// App.TapCoordinates (5, screenSize.Height / 3);
+// App.Screenshot ("Clicked main screen, keyboard should be dismissed");
+// }
+
+// App.ScrollUpForElement (q => q.Marked ("Custom Focused"), 5);
+
+// App.Screenshot ("Label should now say 'Custom Focused'");
+// }
+
+// [Test]
+// [Description ("Enter text in each entry")]
+// public void InputIntentGalleryEnterTextInEachEnry ()
+// {
+
+// AppRect screenSize = App.MainScreenBounds ();
+
+// var inputs = new Dictionary<string, string> () {
+// { "Default", "abc Quick weee!" },
+// { "Email Input", "s@test.com" },
+// { "Text Input", "Hi, I am text!" },
+// { "Url Input", "https://www.xamarin.com/" },
+// { "Numeric Input", "12345678910" },
+// { "Telephone Input", "0000001234" },
+// { "Chat Input", "Sorry, I wasn\'t paying attention." },
+// { "Custom Entry", "I should be custom" }
+// };
+
+// App.Screenshot ("Enter text in each input");
+
+// foreach (var input in inputs) {
+// App.ScrollDownForElement (PlatformQueries.EntryWithPlaceholder (input.Key), 5);
+// App.Tap (PlatformQueries.EntryWithPlaceholder (input.Key));
+// App.EnterText (PlatformQueries.EntryWithPlaceholder (input.Key), input.Value);
+// App.Screenshot ("Text entered");
+// App.TapCoordinates (5, screenSize.Height / 3);
+// App.Screenshot ("Clicked main screen, keyboard should be dismissed");
+// }
+
+// }
+
+// [Test]
+// [Description ("Open keyboard and navigate back without dismissing")]
+// public void InputIntentGalleryNavigateBackWithoutDismissingKeyboard ()
+// {
+// // Should catch any regression of Issue #638, #928
+// var inputs = new List<string> () {
+// "Default",
+// "Email Input",
+// "Text Input",
+// "Url Input",
+// "Numeric Input",
+// "Telephone Input",
+// "Chat Input",
+// "Custom Entry"
+// };
+
+// foreach (string input in inputs) {
+// App.ScrollDownForElement (PlatformQueries.EntryWithPlaceholder (input), 5);
+// App.Tap (PlatformQueries.EntryWithPlaceholder (input));
+// App.Screenshot ("Input Tapped");
+
+// App.Tap (PlatformQueries.Back);
+// App.Screenshot ("Back at Control Gallery");
+// App.ScrollDownForElement (q => q.Button ("InputIntent"), 2);
+// App.Tap (q => q.Button ("InputIntent"));
+// }
+// }
+
+///*******************************************************/
+///**************** Landscape tests **********************/
+///*******************************************************/
+
+// [Test]
+// [Description ("All entries are shown - landscape")]
+// public void InputIntentGalleryAllElementsExistLandscape ()
+// {
+// App.SetOrientationLandscape ();
+// App.Screenshot ("Rotated to Landscape");
+// InputIntentGalleryAllElementsExist ();
+// App.SetOrientationPortrait ();
+// App.Screenshot ("Rotated to portrait");
+// }
+
+// [Test]
+// [Description ("Tap each entry and dismiss keyboard by tapping outside of keyboard - landscape")]
+// public void InputIntentGalleryTapEachEntryLandscape ()
+// {
+// App.SetOrientationLandscape ();
+// App.Screenshot ("Rotated to Landscape");
+// InputIntentGalleryTapEachEntry ();
+// App.SetOrientationPortrait ();
+// App.Screenshot ("Rotated to portrait");
+// }
+
+// [Test]
+// [Description ("Enter text in each entry")]
+// public void InputIntentGalleryEnterTextInEachEnryLandscape ()
+// {
+// App.SetOrientationLandscape ();
+// App.Screenshot ("Rotated to Landscape");
+// InputIntentGalleryEnterTextInEachEnry ();
+// App.SetOrientationPortrait ();
+// App.Screenshot ("Rotated to portrait");
+// }
+
+// [Test]
+// [Description ("Open keyboard and navigate back without dismissing")]
+// public void InputIntentGalleryNavigateBackWithoutDismissingKeyboardLandscape ()
+// {
+// App.SetOrientationLandscape ();
+// App.Screenshot ("Rotated to Landscape");
+// InputIntentGalleryNavigateBackWithoutDismissingKeyboard ();
+// App.SetOrientationPortrait ();
+// App.Screenshot ("Rotated to portrait");
+// }
+
+ }
+}
+
+
diff --git a/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-ListUITests.cs b/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-ListUITests.cs
new file mode 100644
index 0000000..e57ed90
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-ListUITests.cs
@@ -0,0 +1,92 @@
+using NUnit.Framework;
+using Xamarin.UITest;
+
+namespace Xamarin.Forms.Core.UITests
+{
+ [TestFixture]
+ [Category ("ListView")]
+ internal class ListGalleryTests : BaseTestFixture
+ {
+ // TODO
+ // TODO: Port to new conventions
+
+ public ListGalleryTests ()
+ {
+ ShouldResetPerFixture = false;
+ }
+
+ protected override void NavigateToGallery ()
+ {
+ App.NavigateToGallery (GalleryQueries.ListViewGalleryLegacy);
+ }
+// void AllElementsExist ()
+// {
+// for (int i = 0; i < 5; i++)
+// App.WaitForElement (q => q.Marked (i.ToString ()));
+
+// App.Screenshot ("List elements exist");
+// }
+
+ [Test]
+ [Description ("Click 0 - 5 and reset")]
+ public void ListGalleryClickElementsAndReset ()
+ {
+// AllElementsExist ();
+
+// for (int i = 0; i < 5; i++) {
+// App.Tap (q => q.Raw (string.Format ("{0} index:{1}", PlatformStrings.Cell, i)));
+// }
+
+// App.WaitForNoElement (q => q.Marked ("0"), "Timeout : 0");
+// Assert.AreEqual (2, App.Query (q => q.Marked ("5")).Length);
+
+// App.Screenshot ("Clicked 0 - 5");
+
+// App.Tap (q => q.Raw (PlatformStrings.Cell + " index:5"));
+
+// App.WaitForElement (q => q.Marked ("0"), "Timeout : 0");
+// Assert.AreEqual (1, App.Query (q => q.Marked ("5")).Length);
+
+// App.Screenshot ("Reset elements");
+ }
+
+// [Test]
+// [Description ("Scroll to the end of the list")]
+// public void ListGalleryScrollToEndOfList ()
+// {
+// AllElementsExist ();
+
+// for (int i = 0; i < 50; i++)
+// App.ScrollDownForElement (q => q.Marked (i.ToString ()), 2);
+
+// App.Screenshot ("At the bottom of the list");
+// }
+
+///*******************************************************/
+///**************** Landscape tests **********************/
+///*******************************************************/
+
+// [Test]
+// [Description ("Click 0 - 5 and reset - Landscape")]
+// public void ListGalleryClickElementsAndResetLandscape ()
+// {
+// App.SetOrientationLandscape ();
+// App.Screenshot ("Rotated to Landscape");
+// ListGalleryClickElementsAndReset ();
+// App.SetOrientationPortrait ();
+// App.Screenshot ("Rotated to Portrait");
+// }
+
+// [Test]
+// [Description ("Scroll to the end of the list - Landscape")]
+// public void ListGalleryScrollToEndOfListLandscape ()
+// {
+// App.SetOrientationLandscape ();
+// App.Screenshot ("Rotated to Landscape");
+// ListGalleryScrollToEndOfList ();
+// App.SetOrientationPortrait ();
+// App.Screenshot ("Rotated to Portrait");
+// }
+
+ }
+}
diff --git a/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-MapUITests.cs b/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-MapUITests.cs
new file mode 100644
index 0000000..f2d55f3
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-MapUITests.cs
@@ -0,0 +1,110 @@
+using NUnit.Framework;
+using Xamarin.UITest;
+using System.Diagnostics;
+using System.Threading;
+using Xamarin.UITest.Queries;
+
+namespace Xamarin.Forms.Core.UITests
+{
+ [TestFixture]
+ [Category ("Map")]
+ internal class MapGalleryTests : BaseTestFixture
+ {
+ // TODO - Figure out how to implement the map stuff for Android, ie query pins etc
+ // TODO: Port to new conventions
+
+ public MapGalleryTests ()
+ {
+ ShouldResetPerFixture = false;
+ }
+
+ protected override void NavigateToGallery ()
+ {
+ App.NavigateToGallery (GalleryQueries.MapGalleryLegacy);
+ }
+
+ [Test]
+ [Description ("Gallery element are present")]
+ public void MapGalleryAllElementsPresent ()
+ {
+ // CustomScrollDownToBottomForAllElements ();
+ // App.Screenshot ("All elements exist");
+ }
+
+ //[Test]
+ //[Description ("Change MapMapType")]
+ //public void MapGalleryMapType ()
+ //{
+ // AppRect screenBounds = App.MainScreenBounds ();
+ // App.DragFromToForElement (5, q => q.Button ("Map Type"), screenBounds.Width - 15, screenBounds.Height - 100, screenBounds.Width - 15, 15);
+ // App.Tap (q => q.Button ("Map Type"));
+ // App.Screenshot ("Selected Map Type");
+ // App.Tap (q => q.Button ("Satellite"));
+ // App.Screenshot ("Satellite MapType selected");
+ // App.DragFromToForElement (5, PlatformQueries.SearchBars, screenBounds.Width - 15, 75, screenBounds.Width - 15, screenBounds.Height - 100);
+ //}
+
+
+// [Test]
+// public void PinDetails ()
+// {
+// App.Tap (q => q.Raw(PlatformStrings.MapPin + " index:0"));
+// App.WaitForElement (q => q.Marked ("Sistine Chapel"));
+// App.WaitForElement (q => q.Marked ("Piazza della Rotunda, 00186 Rome, Province of Rome, Italy"));
+//
+// App.Screenshot ("First pin");
+//
+// App.Tap (q => q.Raw(PlatformStrings.MapPin + " index:1"));
+// App.WaitForElement (q => q.Marked ("Pantheon"));
+// App.WaitForElement (q => q.Marked ("Piazza del Colosseo, 00186 Rome, Province of Rome, Italy"));
+//
+// App.Screenshot ("Second pin");
+//
+// App.Tap (q => q.Raw(PlatformStrings.MapPin + " index:2"));
+// App.WaitForElement (q => q.Marked ("Colosseum"));
+// App.WaitForElement (q => q.Marked ("Piazza del Colosseo, 00184 Rome, Province of Rome, Italy"));
+//
+// App.Screenshot ("Third pin");
+// }
+
+
+ //void CustomScrollDownToBottomForAllElements ()
+ //{
+ // AppRect screenBounds = App.MainScreenBounds ();
+
+ // App.DragFromToForElement (5, PlatformQueries.SearchBars, screenBounds.Width - 15, screenBounds.Height - 100, screenBounds.Width - 15, 15);
+ // App.DragFromToForElement (5, PlatformQueries.Map, screenBounds.Width - 15, screenBounds.Height - 100, screenBounds.Width - 15, 15);
+
+ // App.DragFromToForElement (5, q => q.Button ("Map Type"), screenBounds.Width - 15, screenBounds.Height - 100, screenBounds.Width - 15, 15);
+ // App.DragFromToForElement (5, q => q.Button ("Zoom In"), screenBounds.Width - 15, screenBounds.Height - 100, screenBounds.Width - 15, 15);
+ // App.DragFromToForElement (5, q => q.Button ("Zoom Out"), 15, screenBounds.Height - 100, 15, 15);
+ // App.DragFromToForElement (5, q => q.Button ("Address From Position"), screenBounds.Width - 15, screenBounds.Height - 100, screenBounds.Width - 15, 15);
+ //}
+
+/*******************************************************/
+/**************** Landscape tests **********************/
+/*******************************************************/
+
+ //[Test]
+ //[Description ("Gallery element are present - Landscape")]
+ //public void MapGalleryAllElementsPresentLandscape ()
+ //{
+ // App.SetOrientationLandscape ();
+ // App.Screenshot ("Rotated to Landscape");
+ // MapGalleryAllElementsPresent ();
+ // App.SetOrientationPortrait ();
+ // App.Screenshot ("Rotated to Portrait");
+ //}
+
+ //[Test]
+ //[Description ("Change MapMapType - Landscape")]
+ //public void MapGalleryMapTypeLandscape ()
+ //{
+ // App.SetOrientationLandscape ();
+ // App.Screenshot ("Rotated to Landscape");
+ // MapGalleryMapType ();
+ // App.SetOrientationPortrait ();
+ // App.Screenshot ("Rotated to Portrait");
+ //}
+ }
+}
diff --git a/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-MinimumSizeUITest.cs b/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-MinimumSizeUITest.cs
new file mode 100644
index 0000000..9de241c
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-MinimumSizeUITest.cs
@@ -0,0 +1,48 @@
+using NUnit.Framework;
+using Xamarin.UITest;
+
+namespace Xamarin.Forms.Core.UITests
+{
+ [TestFixture]
+ [Category ("StackLayout")]
+ internal class MinimumSizeGalleryTests : BaseTestFixture
+ {
+ // TODO
+ // TODO: Port to new conventions
+
+ public MinimumSizeGalleryTests ()
+ {
+ ShouldResetPerFixture = false;
+ }
+
+ protected override void NavigateToGallery ()
+ {
+ App.NavigateToGallery (GalleryQueries.MinimumSizeGalleryLegacy);
+ }
+
+
+ [Test]
+ [Description ("Scroll to the bottom of the TableView")]
+ public void MinimumSizeGalleryTableViewElementsAreAccessible ()
+ {
+ // AllElementsPresent ();
+
+ // var tableView = App.Query (PlatformQueries.Tables) [0];
+
+ // var tableX = tableView.Rect.X;
+ // var tableY = tableView.Rect.Y;
+ // var tableWidth = tableView.Rect.Width;
+ // var tableHeight = tableView.Rect.Height;
+
+ // var elementFound = App.DragFromToForElement (20, q => q.Marked ("Cell 4 Last"), tableWidth / 2, (tableY + tableHeight) - 70, tableWidth / 2, tableY + 30);
+
+ // Assert.IsTrue (elementFound);
+ // App.Screenshot ("All table elements exist");
+ }
+
+/*******************************************************/
+/**************** Landscape tests **********************/
+/*******************************************************/
+
+ }
+}
diff --git a/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-NavigationBarUITests.cs b/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-NavigationBarUITests.cs
new file mode 100644
index 0000000..5af7751
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-NavigationBarUITests.cs
@@ -0,0 +1,57 @@
+using NUnit.Framework;
+using Xamarin.UITest;
+using System;
+using System.Threading;
+using Xamarin.UITest.Queries;
+using System.Diagnostics;
+
+namespace Xamarin.Forms.Core.UITests
+{
+ //[TestFixture]
+ //[Category ("NavigationPage")]
+ internal class NavigationBarGalleryTests : BaseTestFixture
+ {
+ // TODO: Port to new conventions
+
+ public NavigationBarGalleryTests ()
+ {
+ ShouldResetPerFixture = false;
+ }
+
+ protected override void NavigateToGallery ()
+ {
+ //App.NavigateToGallery (GalleryQueries.NavigationBarGalleryLegacy);
+ }
+
+ //[Test]
+ //[Category ("ManualReview")]
+ //[Description ("Change NavigationPage Bar colors")]
+ public void NavigationBarGalleryTestsChangeColors ()
+ {
+ // App.Screenshot ("Background should be green, Text and back button / arrow should be yellow");
+
+ // App.Tap (q => q.Button ("Change BarTextColor"));
+ // App.Screenshot ("Text / back button / arrow should change to teal");
+ // App.Tap (q => q.Button ("Change BarTextColor"));
+ // App.Screenshot ("Text / back button / arrow should change to Color.Default");
+ // App.Tap (q => q.Button ("Change BarTextColor"));
+ // App.Screenshot ("Text / back button / arrow should change to teal");
+
+ // App.Tap (q => q.Button ("Change BarBackgroundColor"));
+ // App.Screenshot ("Background color should change to navy");
+ // App.Tap (q => q.Button ("Change BarBackgroundColor"));
+ // App.Screenshot ("Background color should change to Color.Default");
+ // App.Tap (q => q.Button ("Change BarBackgroundColor"));
+ // App.Screenshot ("Background color should change to navy");
+
+ // App.Tap (q => q.Button ("Change Both to default"));
+ // App.Screenshot ("Background color / text / back button / arrow should change to Color.Default");
+
+ // App.Tap (q => q.Button ("Make sure Tint still works"));
+ // App.Screenshot ("Background arrow should change to red");
+
+ // App.Tap (q => q.Button ("Black background, white text"));
+ // App.Screenshot ("Status bar should be white on iOS");
+ }
+ }
+}
diff --git a/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-RelativeLayoutUITest.cs b/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-RelativeLayoutUITest.cs
new file mode 100644
index 0000000..72171f3
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-RelativeLayoutUITest.cs
@@ -0,0 +1,49 @@
+using NUnit.Framework;
+using Xamarin.UITest;
+using System.Linq;
+
+namespace Xamarin.Forms.Core.UITests
+{
+ [TestFixture]
+ [Category ("RelativeLayout")]
+ internal class RelativeLayoutGalleryTests : BaseTestFixture
+ {
+ // TODO - Add relative layout tests
+ // TODO: Port to new conventions
+
+ public RelativeLayoutGalleryTests ()
+ {
+ ShouldResetPerFixture = false;
+ }
+
+ protected override void NavigateToGallery ()
+ {
+ App.NavigateToGallery (GalleryQueries.RelativeLayoutGalleryLegacy);
+ }
+
+ [Test]
+ [Description ("All elements are present")]
+ public void RelativeLayoutGalleryAllElementsPresent ()
+ {
+// var elements = Enumerable.Range (0, 201).Select (x => x);
+// foreach (int element in elements)
+// App.ScrollDownForElement (q => q.Marked (element.ToString ()), 10);
+ }
+
+///*******************************************************/
+///**************** Landscape tests **********************/
+///*******************************************************/
+
+// [Test]
+// [Description ("All elements are present - Landscape")]
+// public void RelativeLayoutGalleryAllElementsPresentLandscape ()
+// {
+// App.SetOrientationLandscape ();
+// App.Screenshot ("Rotated to Landscape");
+// RelativeLayoutGalleryAllElementsPresent ();
+// App.SetOrientationPortrait ();
+// App.Screenshot ("Rotated to Portrait");
+// }
+
+ }
+}
diff --git a/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-SearchBarUITests.cs b/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-SearchBarUITests.cs
new file mode 100644
index 0000000..d9461cf
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-SearchBarUITests.cs
@@ -0,0 +1,163 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using NUnit.Framework;
+using System.Threading;
+
+namespace Xamarin.Forms.Core.UITests
+{
+ [TestFixture]
+ [Category ("SearchBar")]
+ internal class SearchBarGalleryTests : BaseTestFixture
+ {
+ // TODO: Enter text and try searching
+ // TODO: Port to new conventions
+
+ public SearchBarGalleryTests ()
+ {
+ ShouldResetPerFixture = false;
+ }
+
+ protected override void NavigateToGallery ()
+ {
+ App.NavigateToGallery (GalleryQueries.SearchBarGalleryLegacy);
+ }
+
+ [Test]
+ [Category ("ManualReview")]
+ [Description ("Enter query into each SearchBar")]
+ public void SearchBarGalleryEnterSearchText ()
+ {
+// SearchBarGalleryAllElementsPresent ();
+// for (var i = 0; i < 3; i++) {
+// App.ScrollDownForElement (PlatformQueries.SearchBarWithIndex (i), 5);
+// App.Tap (PlatformQueries.SearchBarWithIndex (i));
+// App.EnterText (PlatformQueries.SearchBarWithIndex (i), "Search: " + i);
+// App.Screenshot ("Keyboard should be shown");
+// App.PressEnter ();
+// App.WaitForElement (q => q.Marked ("Search: " + i));
+// App.Screenshot (string.Format("Keyboard should be dismissed - Label should have changed to 'Search: {0}'", i));
+// }
+
+// App.Tap (q => q.Button ("More SearchBars"));
+// App.WaitForElement (q => q.Marked ("Search Query 2"));
+
+// SearchBarGalleryAllElementsPresentPageTwo ();
+
+// // Disabled keyboard
+// App.Tap (PlatformQueries.SearchBarWithIndex (0));
+// App.Screenshot ("Should not see keyboard for disabled SearchBar");
+
+// App.Tap (PlatformQueries.SearchBarWithIndex (1));
+// App.Screenshot ("Should not see keyboard for disabled SearchBar");
+// App.EnterText (PlatformQueries.SearchBarWithIndex (1), "Entered transparent");
+// App.PressEnter ();
+// App.WaitForElement (q => q.Marked ("Entered transparent"));
+// App.Screenshot ("Entered query for tranparent SearchBar");
+ }
+
+// [Test]
+// [Category ("ManualReview")]
+// [Description ("Enable disable keyboard, Issues #1182, #1237")]
+// public void SearchBarGalleryEnableDisableSearchBar ()
+// {
+// App.Tap (q => q.Button ("More SearchBars"));
+// App.WaitForElement (q => q.Marked ("Search Query 2"));
+
+// SearchBarGalleryAllElementsPresentPageTwo ();
+
+// App.Tap (PlatformQueries.SearchBarWithIndex (0));
+// App.Screenshot ("SearchBar should not be focused, keyboard should not be shown");
+
+// App.Tap (q => q.Button ("Toggle enabled"));
+// App.Tap (PlatformQueries.SearchBarWithIndex (0));
+// App.EnterText (PlatformQueries.SearchBarWithIndex (0), "Now Enabled");
+// App.PressEnter ();
+// App.ScrollDownForElement (q => q.Marked ("Now Enabled"), 2);
+// App.Screenshot ("Enabled and abled to query");
+
+// App.Tap (q => q.Button ("Toggle enabled"));
+// App.Screenshot ("Disabled again");
+
+// App.ScrollUpForElement (PlatformQueries.SearchBarWithIndex (0), 2);
+// App.Tap (PlatformQueries.SearchBarWithIndex (0));
+// App.Screenshot ("SearchBar should not be focused, keyboard should not be shown after diabling once again");
+// }
+
+// [Test]
+//// [Category ("Single")]
+// [Description ("Test the TextChanged event")]
+// public void SearchBarGalleryTextChangedEventTest ()
+// {
+// SearchBarGalleryAllElementsPresent ();
+
+// App.EnterText (PlatformQueries.SearchBarWithIndex (0), "A");
+// App.Screenshot ("Entered three characters in noPlaceholder search bar");
+// var labelText = App.GetTextForQuery (PlatformQueries.LabelWithText ("1"));
+// Assert.AreEqual ("1", labelText);
+
+// App.EnterText (PlatformQueries.SearchBarWithIndex (1), "B");
+// App.Screenshot ("Entered three characters in normal search bar");
+// labelText = App.GetTextForQuery (PlatformQueries.LabelWithText ("2"));
+// Assert.AreEqual ("2", labelText);
+
+// App.EnterText (PlatformQueries.SearchBarWithIndex (2), "C");
+// App.Screenshot ("Entered three characters in activation search bar");
+// labelText = App.GetTextForQuery (PlatformQueries.LabelWithText ("3"));
+// Assert.AreEqual ("3", labelText);
+
+// }
+
+///*******************************************************/
+///**************** Landscape tests **********************/
+///*******************************************************/
+// [Test]
+// [Category ("ManualReview")]
+// [Description ("Enable disable keyboard, Issues #1182, #1237 - landscape")]
+// public void SearchBarGalleryEnableDisableSearchBarLandscape ()
+// {
+// App.SetOrientationLandscape ();
+// App.Screenshot ("Rotated to Landscape");
+// SearchBarGalleryEnableDisableSearchBar ();
+// App.SetOrientationPortrait ();
+// App.Screenshot ("Rotated to Portrait");
+// }
+
+// [Test]
+// [Category ("ManualReview")]
+// [Description ("Enter query into each SearchBar - Landscape")]
+// public void SearchBarGalleryEnterSearchTextLandscape ()
+// {
+// App.SetOrientationLandscape ();
+// App.Screenshot ("Rotated to Landscape");
+// SearchBarGalleryEnterSearchText ();
+// App.SetOrientationPortrait ();
+// App.Screenshot ("Rotated to Portrait");
+// }
+
+// void SearchBarGalleryAllElementsPresent ()
+// {
+// var searchBars = App.Query (PlatformQueries.SearchBars);
+// Assert.AreEqual (3, searchBars.Length);
+
+// App.ScrollDownForElement (q => q.Marked ("Search Query"), 5);
+
+// App.ScrollUp ();
+// App.Screenshot ("All SearchBars present");
+// }
+
+
+
+// void SearchBarGalleryAllElementsPresentPageTwo ()
+// {
+// App.ScrollDownForElement (q => q.Marked ("Search Query 2"), 5);
+// App.ScrollDownForElement (q => q.Button ("Toggle enabled"), 5);
+
+// App.ScrollUp ();
+// App.Screenshot ("All SearchBars present - Page 2");
+// }
+
+ }
+}
diff --git a/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-SliderUITests.cs b/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-SliderUITests.cs
new file mode 100644
index 0000000..11c33d7
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-SliderUITests.cs
@@ -0,0 +1,94 @@
+using NUnit.Framework;
+using Xamarin.UITest;
+
+namespace Xamarin.Forms.Core.UITests
+{
+ [TestFixture]
+ [Category ("Slider")]
+ internal class SliderGalleryTests : BaseTestFixture
+ {
+ // TODO: Detect Slider value changes
+ // TODO: Port to new conventions
+
+ public SliderGalleryTests ()
+ {
+ ShouldResetPerFixture = false;
+ }
+
+ protected override void NavigateToGallery ()
+ {
+ App.NavigateToGallery (GalleryQueries.SliderGalleryLegacy);
+ }
+// void AllElementsPresent ()
+// {
+// var sliders = App.Query (PlatformQueries.Sliders);
+// Assert.AreEqual (3, sliders.Length);
+
+// App.Screenshot ("All Sliders present");
+// }
+
+ [Test]
+ [Description ("Slide all Sliders, test ValueChanged event")]
+ public void SliderGallerySlideAllSliders ()
+ {
+// AllElementsPresent ();
+
+// var sliders = App.Query (PlatformQueries.Sliders);
+// var sliderLeft = sliders[0].Rect.X;
+// var sliderRight = sliderLeft + sliders[0].Rect.Width - 5; // Needed to move 5 pixels left so that the drag would register
+// var topSliderY = sliders[0].Rect.CenterY;
+// var middleSliderY = sliders[1].Rect.CenterY;
+// var bottomSliderY = sliders[2].Rect.CenterY;
+
+// // Move top slider, numbers should change
+// App.DragFromTo (sliderLeft, topSliderY, sliderRight, topSliderY);
+// App.WaitForElement (q => q.Marked ("100"), "Timeout : 100");
+// App.Screenshot ("Move first slider right");
+
+// App.DragFromTo (sliderRight, topSliderY, sliderLeft, topSliderY);
+// App.WaitForElement (q => q.Marked ("20"), "Timeout : 20");
+// App.Screenshot ("Move first slider left");
+
+// // Move middle slider, shouldn't move
+// App.DragFromTo (sliderLeft, middleSliderY, sliderRight, middleSliderY);
+// App.WaitForElement (q => q.Marked ("20"), "Timeout : 20");
+// App.Screenshot ("Tried to move disabled slider");
+
+// // Move bottom slider, should move but nothing happens
+// App.DragFromTo (sliderLeft, bottomSliderY, sliderRight, bottomSliderY);
+// App.WaitForElement (q => q.Marked ("20"), "Timeout : 20");
+// App.Screenshot ("Move third slider right");
+
+// App.DragFromTo (sliderRight, bottomSliderY, sliderLeft, bottomSliderY);
+// App.WaitForElement (q => q.Marked ("20"), "Timeout : 20");
+// App.Screenshot ("Move first slider left");
+
+ }
+
+///*******************************************************/
+///**************** Landscape tests **********************/
+///*******************************************************/
+
+// [Test]
+// public void AllElementsPresentLandscape ()
+// {
+// App.SetOrientationLandscape ();
+// App.Screenshot ("Rotated to Landscape");
+// AllElementsPresent ();
+// App.SetOrientationPortrait ();
+// App.Screenshot ("Rotated to Portrait");
+// }
+
+// [Test]
+// [Description ("Slide all Sliders - Landscape")]
+// public void SliderGallerySlideAllSlidersLandscape ()
+// {
+// App.SetOrientationLandscape ();
+// App.Screenshot ("Rotated to Landscape");
+// SliderGallerySlideAllSliders ();
+// App.SetOrientationPortrait ();
+// App.Screenshot ("Rotated to Portrait");
+// }
+
+ }
+}
diff --git a/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-StackLayoutUITest.cs b/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-StackLayoutUITest.cs
new file mode 100644
index 0000000..b17c7ec
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-StackLayoutUITest.cs
@@ -0,0 +1,76 @@
+using NUnit.Framework;
+using Xamarin.UITest;
+using System.Collections.Generic;
+
+namespace Xamarin.Forms.Core.UITests
+{
+ [TestFixture]
+ [Category ("StackLayout")]
+ internal class StackLayoutGalleryTests : BaseTestFixture
+ {
+ // TODO
+ // TODO: Port to new conventions
+
+ public StackLayoutGalleryTests ()
+ {
+ ShouldResetPerFixture = false;
+ }
+
+ protected override void NavigateToGallery ()
+ {
+ App.NavigateToGallery (GalleryQueries.StackLayoutGalleryLegacy);
+ }
+
+// void AllElementsPresent ()
+// {
+// var buttons = new [] {
+// "Boring",
+// "Exciting!",
+// "Amazing!",
+// "Meh"
+// };
+
+// foreach (var button in buttons) {
+// App.WaitForElement (q => q.Button (button));
+// }
+
+// App.Screenshot ("All elements exist");
+// }
+
+ [Test]
+ [Description ("Check that each button is there and click them")]
+ public void StackLayoutGalleryClickEachButton ()
+ {
+// AllElementsPresent ();
+
+// App.Tap (q => q.Button ("Boring"));
+// App.WaitForElement (q => q.Button ("clicked1"), "Timeout : clicked1");
+
+// App.Tap (q => q.Button ("Exciting!"));
+// App.WaitForElement (q => q.Button ("clicked2"), "Timeout : clicked2");
+
+// App.Tap (q => q.Button ("Amazing!"));
+// App.WaitForElement (q => q.Button ("clicked3"), "Timeout : clicked3");
+
+// App.Tap (q => q.Button ("Meh"));
+// App.WaitForElement (q => q.Button ("clicked4"), "Timeout : clicked4");
+
+// App.Screenshot ("All buttons clicked");
+ }
+
+///*******************************************************/
+///**************** Landscape tests **********************/
+///*******************************************************/
+// [Test]
+// [Description ("Check that each button is there and click them - Landscape")]
+// public void StackLayoutGalleryClickEachButtonLandscape ()
+// {
+// App.SetOrientationLandscape ();
+// App.Screenshot ("Rotated to Landscape");
+// StackLayoutGalleryClickEachButton ();
+// App.SetOrientationPortrait ();
+// App.Screenshot ("Rotated to Portrait");
+// }
+
+ }
+}
diff --git a/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-StepperUITests.cs b/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-StepperUITests.cs
new file mode 100644
index 0000000..a468e31
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-StepperUITests.cs
@@ -0,0 +1,93 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using NUnit.Framework;
+using System.Diagnostics;
+
+namespace Xamarin.Forms.Core.UITests
+{
+ [TestFixture]
+ [Category ("Stepper")]
+ internal class StepperGalleryTests : BaseTestFixture
+ {
+ // TODO: Checking enabled / disabled states
+ // TODO: Port to new conventions
+
+ public StepperGalleryTests ()
+ {
+ ShouldResetPerFixture = false;
+ }
+
+ protected override void NavigateToGallery ()
+ {
+ App.NavigateToGallery (GalleryQueries.StepperGalleryLegacy);
+ }
+
+ [Test]
+ [Description ("Check all elements exist")]
+ public void StepperGalleryAllElementsPresent ()
+ {
+// App.WaitForElement (PlatformQueries.LabelWithText ("0"));
+// var labels = App.Query (PlatformQueries.LabelWithText ("0"));
+// Assert.AreEqual (2, labels.Length);
+
+// var steppers = App.Query (PlatformQueries.Steppers);
+// Assert.AreEqual (2, steppers.Length);
+
+// App.Screenshot ("All elements exist");
+ }
+
+// [Test]
+// [Description ("Check that value changed event fires")]
+// public void StepperGalleryValueChangedEventTest ()
+// {
+// StepperGalleryAllElementsPresent ();
+// var labelText = "";
+// for (int i = 1; i <= 5; i++) {
+// App.Tap (PlatformQueries.StepperWithIndex (0));
+// App.Screenshot (string.Format ("Tapped first stepper {0} times", i));
+// App.WaitForElement (PlatformQueries.LabelWithText ((i*10).ToString ()));
+// labelText = App.GetTextForQuery (PlatformQueries.LabelWithText ((i*10).ToString ()));
+// Assert.AreEqual ((i*10).ToString (), labelText);
+// }
+
+// for (int i = 1; i <= 5; i++) {
+// App.Tap (PlatformQueries.StepperWithIndex (1));
+// App.Screenshot (string.Format ("Tapped second stepper {0} times", i));
+// App.WaitForElement (PlatformQueries.LabelWithText ((i*.05).ToString ()));
+// labelText = App.GetTextForQuery (PlatformQueries.LabelWithText ((i*.05).ToString ()));
+// Assert.AreEqual ((i*.05).ToString (), labelText);
+// }
+// }
+
+///*******************************************************/
+///**************** Landscape tests **********************/
+///*******************************************************/
+
+// [Test]
+// [Description ("Check all elements exist - Landscape")]
+// public void StepperGalleryAllElementsPresetLandscape ()
+// {
+// App.SetOrientationLandscape ();
+// App.Screenshot ("Rotated to Landscape");
+// StepperGalleryAllElementsPresent ();
+// App.SetOrientationPortrait ();
+// App.Screenshot ("Rotated to Portrait");
+// }
+
+// [Test]
+// [Description ("Check that events fire - Landscape")]
+//// [Category ("Single")]
+// public void StepperGalleryEventTestLandscape ()
+// {
+// App.SetOrientationLandscape ();
+// App.Screenshot ("Rotated to Landscape");
+// StepperGalleryValueChangedEventTest ();
+// App.SetOrientationPortrait ();
+// App.Screenshot ("Rotated to Portrait");
+// }
+
+ }
+}
diff --git a/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-SwitchUITests.cs b/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-SwitchUITests.cs
new file mode 100644
index 0000000..67a23d8
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-SwitchUITests.cs
@@ -0,0 +1,104 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using NUnit.Framework;
+using System.Diagnostics;
+
+namespace Xamarin.Forms.Core.UITests
+{
+ [TestFixture]
+ [Category ("Switch")]
+ internal class SwitchGalleryTests : BaseTestFixture
+ {
+ // TODO: Checking enabled / disabled states
+ // TODO: Port to new conventions
+
+ public SwitchGalleryTests ()
+ {
+ ShouldResetPerFixture = false;
+ }
+
+ protected override void NavigateToGallery ()
+ {
+ App.NavigateToGallery (GalleryQueries.SwitchGalleryLegacy);
+ }
+
+ [Test]
+ [Description ("Check all elements exist")]
+ public void SwitchGalleryAllElementsPresent ()
+ {
+// var label = App.Query (PlatformQueries.LabelWithText("Test Label"));
+// Assert.AreEqual (1, label.Length);
+
+// var switches = App.Query (q => q.Raw ("Switch"));
+// Assert.AreEqual (3, switches.Length);
+
+// var steppers = App.Query (PlatformQueries.Steppers);
+// Assert.AreEqual (1, steppers.Length);
+
+// App.Screenshot ("All elements exist");
+ }
+
+// [Test]
+// [Description ("Check that events fire")]
+//// [Category ("Single")]
+// public void SwitchGalleryEventTest ()
+// {
+// App.Tap (PlatformQueries.SwitchWithIndex (0));
+// App.Screenshot ("Toggled normal switch");
+// App.WaitForElement (PlatformQueries.LabelWithText ("Toggled normal switch"));
+// var labelText = App.GetTextForQuery (PlatformQueries.LabelWithText ("Toggled normal switch"));
+// Assert.AreEqual ("Toggled normal switch", labelText);
+
+// App.Tap (PlatformQueries.SwitchWithIndex (1));
+// App.Screenshot ("Tried to toggle disabled switch");
+// App.WaitForElement (PlatformQueries.LabelWithText ("Toggled normal switch"));
+// labelText = App.GetTextForQuery (PlatformQueries.LabelWithText ("Toggled normal switch"));
+// Assert.AreEqual ("Toggled normal switch", labelText);
+
+// App.Tap (PlatformQueries.SwitchWithIndex (2));
+// App.Screenshot ("Toggled transparent switch");
+// App.WaitForElement (PlatformQueries.LabelWithText ("Toggled transparent switch"));
+// labelText = App.GetTextForQuery (PlatformQueries.LabelWithText ("Toggled transparent switch"));
+// Assert.AreEqual ("Toggled transparent switch", labelText);
+
+// for (int i = 1; i <= 5; i++) {
+// App.Tap (PlatformQueries.Steppers);
+// App.Screenshot (string.Format ("Tapped stepper {0} times", i));
+// App.WaitForElement (PlatformQueries.LabelWithText (i.ToString ()));
+// labelText = App.GetTextForQuery (PlatformQueries.LabelWithText (i.ToString ()));
+// Assert.AreEqual (i.ToString (), labelText);
+// }
+// }
+
+///*******************************************************/
+///**************** Landscape tests **********************/
+///*******************************************************/
+
+// [Test]
+// [Description ("Check all elements exist - Landscape")]
+// public void SwitchGalleryAllElementsPresetLandscape ()
+// {
+// App.SetOrientationLandscape ();
+// App.Screenshot ("Rotated to Landscape");
+// SwitchGalleryAllElementsPresent ();
+// App.SetOrientationPortrait ();
+// App.Screenshot ("Rotated to Portrait");
+// }
+
+// [Test]
+// [Description ("Check that events fire - Landscape")]
+//// [Category ("Single")]
+// public void SwitchGalleryEventTestLandscape ()
+// {
+// App.SetOrientationLandscape ();
+// App.Screenshot ("Rotated to Landscape");
+// SwitchGalleryEventTest ();
+// App.SetOrientationPortrait ();
+// App.Screenshot ("Rotated to Portrait");
+// }
+
+ }
+}
diff --git a/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-TableViewUITests.cs b/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-TableViewUITests.cs
new file mode 100644
index 0000000..5f9bd80
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-TableViewUITests.cs
@@ -0,0 +1,76 @@
+using System;
+using System.Runtime;
+using NUnit.Framework;
+using Xamarin.UITest;
+using Xamarin.UITest.Android;
+using Xamarin.UITest.iOS;
+
+namespace Xamarin.Forms.Core.UITests
+{
+ [TestFixture]
+ [Category ("TableView")]
+ internal class TableViewGalleryTests : BaseTestFixture
+ {
+
+ // TODO: test sizes
+ // TODO: Port to new conventions
+
+ public TableViewGalleryTests ()
+ {
+ ShouldResetPerFixture = false;
+ }
+
+ protected override void NavigateToGallery ()
+ {
+ App.NavigateToGallery (GalleryQueries.TableViewGalleryLegacy);
+ }
+
+ [Test]
+ [Description ("Elements of section header are present")]
+ public void TableViewGalleryHeader ()
+ {
+// App.WaitForElement (q => q.Marked ("Section One"), "Timeout : Section One");
+// App.Screenshot ("Header is present");
+ }
+
+// [Test]
+// [Description ("TableCells are present")]
+// public void TableViewGalleryTableCellsArePresent ()
+// {
+// var list = App.Query (PlatformQueries.Tables);
+// Assert.AreEqual (1, list.Length);
+// App.WaitForElement (q => q.Marked ("View Cell 1"), "Timeout : View Cell 1");
+// App.WaitForElement (q => q.Marked ("View Cell 2"), "Timeout : View Cell 2");
+
+// App.Screenshot ("TableCells are present");
+// }
+
+///*******************************************************/
+///**************** Landscape tests **********************/
+///*******************************************************/
+
+// [Test]
+// [Description ("Elements of CustomHeader are present - Landscape")]
+// public void TableViewGalleryCustomHeaderLandscape ()
+// {
+// App.SetOrientationLandscape ();
+// App.Screenshot ("Rotated to Landscape");
+// TableViewGalleryHeader ();
+// App.SetOrientationPortrait ();
+// App.Screenshot ("Rotated to Portrait");
+// }
+
+// [Test]
+// [Description ("TableCells are present - Landscape")]
+// public void TableViewGalleryTableCellsArePresentLandscape ()
+// {
+// App.SetOrientationLandscape ();
+// App.Screenshot ("Rotated to Landscape");
+// TableViewGalleryTableCellsArePresent ();
+// App.SetOrientationPortrait ();
+// App.Screenshot ("Rotated to Portrait");
+// }
+
+ }
+}
+
diff --git a/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-TemplatedCarouselPageUITests.cs b/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-TemplatedCarouselPageUITests.cs
new file mode 100644
index 0000000..f01641a
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-TemplatedCarouselPageUITests.cs
@@ -0,0 +1,407 @@
+using NUnit.Framework;
+using Xamarin.UITest;
+using System.Threading;
+using Xamarin.UITest.Queries;
+using System;
+
+namespace Xamarin.Forms.Core.UITests
+{
+ [TestFixture]
+ [Category ("Templated")]
+ internal class TemplatedCarouselPageGalleryTests : BaseTestFixture
+ {
+ // TODO: Port to new conventions
+
+ public TemplatedCarouselPageGalleryTests ()
+ {
+ ShouldResetPerFixture = false;
+ }
+
+ protected override void NavigateToGallery ()
+ {
+ App.NavigateToGallery (GalleryQueries.TemplatedCarouselPageGalleryLegacy);
+ }
+ //AppRect scrollContainerBounds = new AppRect ();
+
+// void AllElementsPresent ()
+// {
+// AllElementExistForPage (0);
+
+// App.Screenshot ("All elements found on page 0");
+
+// SwipeLeft ();
+
+// App.Screenshot ("Swiped left");
+
+// AllElementExistForPage (1);
+
+// App.Screenshot ("All elements found on page 1");
+// }
+
+ [Test]
+ [Description ("Insert page")]
+ public void TemplatedCarouselPageGalleryInsertPage ()
+ {
+// AllElementsPresent ();
+
+// App.Tap (q => q.Button ("Insert Tab: 1"));
+
+// SwipeLeft ();
+
+// AllElementExistForPage (2);
+// App.Screenshot ("At page 2");
+
+// SwipeRight ();
+
+// AllElementExistForPage (1);
+// App.Screenshot ("At page 1");
+
+// SwipeRight ();
+
+// AllElementExistForPage (0);
+// App.Screenshot ("At page 0");
+ }
+
+// [Test]
+// [Description ("Remove page")]
+// public void TemplatedCarouselPageGalleryRemovePage ()
+// {
+// AllElementsPresent ();
+
+// App.Tap (q => q.Button ("Remove Tab: 1"));
+
+// AllElementExistForPage (0);
+// App.Screenshot ("Removed page 1");
+// }
+
+// [Test]
+// [Description ("Insert / Remove page")]
+// public void TemplatedCarouselPageGalleryAddRemovePage ()
+// {
+// AllElementsPresent ();
+
+// App.Tap (q => q.Button ("Insert Tab: 1"));
+
+// SwipeLeft ();
+
+// AllElementExistForPage (2);
+// App.Screenshot ("At page 2");
+
+// App.Tap (q => q.Button ("Remove Tab: 2"));
+// AllElementExistForPage (0);
+// App.Screenshot ("Removed page 2");
+
+// SwipeLeft ();
+
+// App.Tap (q => q.Button ("Remove Tab: 1"));
+// AllElementExistForPage (0);
+// App.Screenshot ("Removed page 1");
+// }
+
+// [Test]
+// [Description ("Reset pages")]
+// public void TemplatedCarouselPageGalleryResetAllPages ()
+// {
+// AllElementsPresent ();
+
+// App.WaitForElement (q => q.Button ("Insert Tab: 1"));
+// App.Tap (q => q.Button ("Insert Tab: 1"));
+
+// SwipeLeft ();
+// AllElementExistForPage (2);
+// App.Tap (q => q.Button ("Insert Tab: 2"));
+
+// SwipeLeft ();
+// AllElementExistForPage (3);
+// App.Screenshot ("At page 3");
+
+// SwipeRight ();
+// App.Tap (q => q.Button ("Reset all tabs: 2"));
+
+// AllElementExistForPage (0);
+// App.Screenshot ("Pages reset");
+
+// SwipeLeft ();
+// AllElementExistForPage (1);
+// App.Screenshot ("On Page 1 again");
+
+// SwipeLeft ();
+// AllElementExistForPage (1);
+// App.Screenshot ("On Page 1 again");
+// }
+
+// [Test]
+// [Description ("Insert / go to next pages")]
+// public void TemplatedCarouselPageGalleryNextPage ()
+// {
+// TemplatedCarouselPageGalleryInsertPage ();
+
+// AppRect screenSize = App.MainScreenBounds ();
+// ScrollDownForQuery (q => q.Button ("Delayed reset: 0"), scrollContainerBounds);
+// App.Tap (q => q.Button ("Next Page: 0"));
+// AllElementExistForPage (1);
+// App.Screenshot ("At page 1");
+
+// ScrollDownForQuery (q => q.Button ("Delayed reset: 1"), scrollContainerBounds);
+// App.Tap (q => q.Button ("Next Page: 1"));
+// AllElementExistForPage (2);
+// App.Screenshot ("At page 2");
+
+// ScrollDownForQuery (q => q.Button ("Delayed reset: 2"), scrollContainerBounds);
+// App.Tap (q => q.Button ("Next Page: 2"));
+// AllElementExistForPage (0);
+// App.Screenshot ("At page 0");
+// }
+
+// [Test]
+// [Description ("Reproduction for a crash related to adding / reseting pages")]
+// public void TemplatedCarouselPageGalleryAddResetCrash ()
+// {
+// AllElementsPresent ();
+
+// SwipeRight ();
+
+// App.Tap (q => q.Button ("Insert Tab: 0"));
+// App.Tap (q => q.Button ("Insert Tab: 0"));
+// App.Screenshot ("Added two pages from Page 0");
+
+// SwipeLeft ();
+// App.Tap (q => q.Button ("Insert Tab: 3"));
+// App.Tap (q => q.Button ("Insert Tab: 3"));
+// App.Screenshot ("Added two pages from Page 3");
+
+// App.Tap (q => q.Button ("Reset all tabs: 3"));
+// AllElementExistForPage (0);
+// App.Screenshot ("Pages reset without crashing");
+// }
+
+// [Test]
+// [Description ("Reproduction for a crash related to adding / reseting pages")]
+// public void TemplatedCarouselPageGalleryAnotherAddResetCrash ()
+// {
+// AllElementsPresent ();
+
+// App.WaitForElement (q => q.Button ("Insert Tab: 1"));
+// App.Tap (q => q.Button ("Insert Tab: 1"));
+
+// SwipeLeft ();
+
+// AllElementExistForPage (2);
+// App.Screenshot ("At page 2");
+
+// App.Tap (q => q.Button ("Reset all tabs: 2"));
+// App.WaitForElement (q => q.Marked ("Insert Tab: 0"));
+// AllElementExistForPage (0);
+// }
+
+// [Test]
+// [Description ("Delayed reset of all content")]
+// public void TemplatedCarouselPageGalleryDelayResetAllElements ()
+// {
+// AllElementsPresent ();
+
+// App.ScrollDownForElement (q => q.Button ("Delayed reset: 1"), 2);
+// App.Tap (q => q.Button ("Delayed reset: 1"));
+
+// App.WaitForNoElement (q => q.Marked ("Lorem ipsum dolor sit amet #1"));
+// App.WaitForElement (q => q.Marked ("Insert Tab: 0"));
+// AllElementExistForPage (0);
+// }
+
+// [Test]
+// [Description ("Reproduction for a crash related to removing the first page")]
+// public void TemplatedCarouselPageGalleryRemoveFirstPageAndResetCrash ()
+// {
+// AllElementsPresent ();
+
+// SwipeRight ();
+// AllElementExistForPage (0);
+
+// App.Tap (q => q.Marked ("Remove Tab: 0"));
+// App.Screenshot ("Remove first page");
+
+// AllElementExistForPage (1);
+// App.Tap (q => q.Marked ("Reset all tabs: 1"));
+
+// AllElementExistForPage (0);
+// App.Screenshot ("Reset all pages");
+// }
+
+// void SwipeLeft ()
+// {
+
+// AppRect swipeLabelBounds = App.Query (q => q.Marked ("Swipe Here"))[0].Rect;
+// // Account for padded scrollview implementations on the different platforms
+// App.DragFromTo (
+// scrollContainerBounds.X + scrollContainerBounds.Width - PlatformValues.OffsetForScrollView,
+// swipeLabelBounds.CenterY,
+// scrollContainerBounds.X + PlatformValues.OffsetForScrollView,
+// swipeLabelBounds.CenterY
+// );
+// Thread.Sleep (2000);
+// }
+
+// void SwipeRight ()
+// {
+
+// AppRect swipeLabelBounds = App.Query (q => q.Marked ("Swipe Here"))[0].Rect;
+// // Account for padded scrollview implementations on the different platforms
+// App.DragFromTo (
+// scrollContainerBounds.X + PlatformValues.OffsetForScrollView,
+// swipeLabelBounds.CenterY,
+// scrollContainerBounds.X + scrollContainerBounds.Width - PlatformValues.OffsetForScrollView,
+// swipeLabelBounds.CenterY
+// );
+// Thread.Sleep (2000);
+// }
+
+// void ScrollDownForQuery (Func<AppQuery, AppQuery> query, AppRect scrollContainer)
+// {
+// AppRect screenSize = App.MainScreenBounds ();
+// float swipeY = scrollContainer.X + 5;
+// App.DragFromToForElement (5, query, swipeY, (2 / 3.0f) * screenSize.Height, swipeY, screenSize.Height / 3.0f);
+// }
+
+// void ScrollUpForQuery (Func<AppQuery, AppQuery> query, AppRect scrollContainer)
+// {
+// AppRect screenSize = App.MainScreenBounds ();
+// float swipeY = scrollContainer.X + 5;
+// App.DragFromToForElement (2, query, swipeY, screenSize.Height / 3.0f, swipeY, (2 / 3.0f) * screenSize.Height);
+// }
+
+
+// void AllElementExistForPage (int index)
+// {
+// var title = "Lorem ipsum dolor sit amet #" + index;
+// // Wait for element to load before querying its parent (problem on iOS)
+// if (App.Query (q => q.Marked (title)).Length < 1)
+// App.ScrollUpForElement (q => q.Marked (title), 3);
+// App.WaitForElement (q => q.Marked (title));
+// scrollContainerBounds = App.Query (q => q.Marked (title).Parent ())[2].Rect;
+
+// ScrollUpForQuery (q => q.Marked (title), scrollContainerBounds);
+
+// var buttons = new [] {
+// "Insert Tab: " + index,
+// "Change title: " + index,
+// "Remove Tab: " + index,
+// "Reset all tabs: " + index,
+// "Next Page: " + index,
+// "Delayed reset: " + index,
+// };
+
+// App.WaitForElement (q => q.Marked (title), "Timeout: " + title);
+
+// foreach (var button in buttons) {
+// if (App.Query (q => q.Button (button)).Length < 1)
+// ScrollDownForQuery (q=> q.Button (button), scrollContainerBounds);
+// App.WaitForElement (q => q.Button (button));
+// }
+// ScrollUpForQuery (q => q.Marked (title), scrollContainerBounds);
+// }
+
+///*******************************************************/
+///**************** Landscape tests **********************/
+///*******************************************************/
+
+// [Test]
+// [Description ("Insert page - Landscape")]
+// public void TemplatedCarouselPageGalleryInsertPageLandscape ()
+// {
+// App.SetOrientationLandscape ();
+// App.Screenshot ("Rotated to Landscape");
+// TemplatedCarouselPageGalleryInsertPage ();
+// App.SetOrientationPortrait ();
+// App.Screenshot ("Rotated to Portrait");
+// }
+
+// [Test]
+// [Description ("Remove page - Landscape")]
+// public void TemplatedCarouselPageGalleryRemovePageLandscape ()
+// {
+// App.SetOrientationLandscape ();
+// App.Screenshot ("Rotated to Landscape");
+// TemplatedCarouselPageGalleryRemovePage ();
+// App.SetOrientationPortrait ();
+// App.Screenshot ("Rotated to Portrait");
+// }
+
+// [Test]
+// [Description ("Insert / Remove page - Landscape")]
+// public void TemplatedCarouselPageGalleryAddRemovePageLandscape ()
+// {
+// App.SetOrientationLandscape ();
+// App.Screenshot ("Rotated to Landscape");
+// TemplatedCarouselPageGalleryAddRemovePage ();
+// App.SetOrientationPortrait ();
+// App.Screenshot ("Rotated to Portrait");
+// }
+
+// [Test]
+// [Description ("Reset pages - Landscape")]
+// public void TemplatedCarouselPageGalleryResetAllPagesLandscape ()
+// {
+// App.SetOrientationLandscape ();
+// App.Screenshot ("Rotated to Landscape");
+// TemplatedCarouselPageGalleryResetAllPages ();
+// App.SetOrientationPortrait ();
+// App.Screenshot ("Rotated to Portrait");
+// }
+
+// [Test]
+// [Description ("Insert / go to next pages - Landscape")]
+// public void TemplatedCarouselPageGalleryNextPageLandscape ()
+// {
+// App.SetOrientationLandscape ();
+// App.Screenshot ("Rotated to Landscape");
+// TemplatedCarouselPageGalleryNextPage ();
+// App.SetOrientationPortrait ();
+// App.Screenshot ("Rotated to Portrait");
+// }
+
+// [Test]
+// [Description ("Reproduction for a crash related to adding / reseting pages - Landscape")]
+// public void TemplatedCarouselPageGalleryAddResetCrashLandscape ()
+// {
+// App.SetOrientationLandscape ();
+// App.Screenshot ("Rotated to Landscape");
+// TemplatedCarouselPageGalleryAddResetCrash ();
+// App.SetOrientationPortrait ();
+// App.Screenshot ("Rotated to Portrait");
+// }
+
+// [Test]
+// [Description ("Reproduction for a crash related to adding / reseting pages - Landscape")]
+// public void TemplatedCarouselPageGalleryAnotherAddResetCrashLandscape ()
+// {
+// App.SetOrientationLandscape ();
+// App.Screenshot ("Rotated to Landscape");
+// TemplatedCarouselPageGalleryAnotherAddResetCrash ();
+// App.SetOrientationPortrait ();
+// App.Screenshot ("Rotated to Portrait");
+// }
+
+// [Test]
+// [Description ("Delayed reset of all content - Landscape")]
+// public void TemplatedCarouselPageGalleryDelayResetAllElementsLandscape ()
+// {
+// App.SetOrientationLandscape ();
+// App.Screenshot ("Rotated to Landscape");
+// TemplatedCarouselPageGalleryDelayResetAllElements ();
+// App.SetOrientationPortrait ();
+// App.Screenshot ("Rotated to Portrait");
+// }
+
+// [Test]
+// [Description ("Reproduction for a crash related to removing the first page - Landscape")]
+// public void TemplatedCarouselPageGalleryRemoveFirstPageAndResetCrashLandscape ()
+// {
+// App.SetOrientationLandscape ();
+// App.Screenshot ("Rotated to Landscape");
+// TemplatedCarouselPageGalleryRemoveFirstPageAndResetCrash ();
+// App.SetOrientationPortrait ();
+// App.Screenshot ("Rotated to Portrait");
+// }
+
+ }
+}
diff --git a/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-TemplatedTabPageUITests.cs b/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-TemplatedTabPageUITests.cs
new file mode 100644
index 0000000..180c7bf
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-TemplatedTabPageUITests.cs
@@ -0,0 +1,346 @@
+using NUnit.Framework;
+using Xamarin.UITest;
+using Xamarin.UITest.Queries;
+using System;
+
+namespace Xamarin.Forms.Core.UITests
+{
+ [TestFixture]
+ [Category ("Templated")]
+ internal class TemplatedTabPageGalleryTests : BaseTestFixture
+ {
+ // TODO
+ // TODO: Port to new conventions
+
+ public TemplatedTabPageGalleryTests ()
+ {
+ ShouldResetPerFixture = false;
+ }
+
+ protected override void NavigateToGallery ()
+ {
+ App.NavigateToGallery (GalleryQueries.TemplatedTabbedPageGalleryLegacy);
+ }
+
+// void AllElementsExist ()
+// {
+// var labels = new [] {
+// "Lorem ipsum dolor sit amet #0",
+// "Page 0",
+// "Page 1",
+// };
+
+// foreach (var label in labels)
+// App.WaitForElement (q => q.Marked (label), "Timeout : " + label);
+
+// AllElementExistForPage (0);
+
+// App.Tap (q => q.Marked ("Page 1"));
+// AllElementExistForPage (1);
+
+// App.Screenshot ("All elements exist");
+// }
+
+ [Test]
+ [Description ("Insert tab")]
+ public void TemplatedTabPageGalleryInsertTab ()
+ {
+// AllElementsExist ();
+
+// App.Tap (q => q.Button ("Insert Tab: 1"));
+// App.WaitForElement (q => q.Marked ("Page 2"), "Timeout : Page 2");
+
+// App.Screenshot ("Page 2 added");
+
+// App.Tap (q => q.Marked ("Page 2"));
+// AllElementExistForPage (2);
+
+// App.Screenshot ("Page 2 selected");
+ }
+
+// [Test]
+// [Description ("Insert tab crash reproduction")]
+// public void TemplatedTabPageGalleryInsertTabCrash ()
+// {
+// TemplatedTabPageGalleryInsertTab ();
+// App.Tap (q => q.Marked ("Page 1"));
+// AllElementExistForPage (1);
+
+// App.Tap (q => q.Marked ("Page 0"));
+// AllElementExistForPage (0);
+// }
+
+// [Test]
+// [Description ("Change tab Title")]
+// public void TemplatedTabPageGalleryChangeTitles ()
+// {
+// AllElementsExist ();
+// App.Tap (q => q.Marked ("Change title: 1"));
+// App.WaitForNoElement (q => q.Marked ("Page 1"), "Timeout : Page 1");
+
+// // Change Page 1 title
+// for (int i = 0; i < 3; i++) {
+// App.WaitForElement (q => q.Marked ("Title: " + i), "Timeout : Title " + i);
+// App.Tap (q => q.Marked ("Change title: 1"));
+// }
+
+// App.Screenshot ("Page 1 titles changed");
+
+// // Change Page 0 title
+// App.Tap (q => q.Marked ("Page 0"));
+// App.Tap (q => q.Button ("Change title: 0"));
+// App.WaitForNoElement (q => q.Marked ("Page 0"), "Timeout : Page 0");
+
+// for (int i = 0; i < 3; i++) {
+// App.WaitForElement (q => q.Marked ("Title: " + i), "Timeout : Title " + i);
+// App.Tap (q => q.Button ("Change title: 0"));
+// }
+
+// App.Screenshot ("Page 0 titles changed");
+// }
+
+// [Test]
+// [Description ("Move tabs")]
+// public void TemplatedTabPageGalleryMoveTabs ()
+// {
+// AllElementsExist ();
+
+// int pageZeroTabIndex = App.IndexForElementWithText (PlatformQueries.Labels, "Page 0");
+// int pageOneTabIndex = App.IndexForElementWithText (PlatformQueries.Labels, "Page 1");
+
+// // Elements found
+// Assert.AreNotEqual (-1, pageZeroTabIndex);
+// Assert.AreNotEqual (-1, pageOneTabIndex);
+
+// Assert.Greater (pageOneTabIndex, pageZeroTabIndex);
+
+// App.Screenshot ("Tabs before move");
+
+// App.Tap (q => q.Button ("Move Tab: 1"));
+
+// int pageZeroMovedTabIndex = App.IndexForElementWithText (PlatformQueries.Labels, "Page 0");
+// int pageOneMovedTabIndex = App.IndexForElementWithText (PlatformQueries.Labels, "Page 1");
+
+// // Elements found
+// Assert.AreNotEqual (-1, pageZeroMovedTabIndex);
+// Assert.AreNotEqual (-1, pageOneMovedTabIndex);
+
+// Assert.Greater (pageZeroMovedTabIndex, pageOneMovedTabIndex);
+
+// App.Screenshot ("Tabs after move");
+// }
+
+// [Test]
+// [Description ("Remove tabs")]
+// public void TemplatedTabPageGalleryRemoveTabs ()
+// {
+// AllElementsExist ();
+
+// App.Tap (q => q.Button ("Remove Tab: 1"));
+// App.WaitForNoElement (q => q.Marked ("Page 1"), "Timeout : Page 1");
+
+// App.Screenshot ("Remove Page 1");
+// }
+
+// [Test]
+// [Description ("Add / remove tabs")]
+// public void TemplatedTabPageGalleryAddRemoveTabs ()
+// {
+// TemplatedTabPageGalleryInsertTab ();
+
+// App.Tap (q => q.Button ("Remove Tab: 2"));
+// App.WaitForNoElement (q => q.Marked ("Page 2"), "Timeout : Page 2");
+
+// App.Screenshot ("Remove Page 2");
+
+// App.Tap (q => q.Button ("Remove Tab: 0"));
+// App.WaitForNoElement (q => q.Marked ("Page 0"), "Timeout : Page 0");
+
+// App.Screenshot ("Remove Page 0");
+
+// AllElementExistForPage (1);
+// }
+
+// [Test]
+// [Description ("Reset tabs")]
+// public void TemplatedTabPageGalleryResetAllTabs ()
+// {
+// TemplatedTabPageGalleryChangeTitles ();
+
+// App.Tap (q => q.Button ("Insert Tab: 0"));
+// App.WaitForElement (q => q.Marked ("Page 2"), "Timeout : Page 2");
+
+// App.Screenshot ("Page 2 added");
+
+// App.Tap (q => q.Marked ("Page 2"));
+// AllElementExistForPage (2);
+
+// App.Screenshot ("Page 2 selected");
+
+// App.ScrollDownForElement (q => q.Button ("Reset all tabs: 2"), 3);
+// App.Tap (q => q.Button ("Reset all tabs: 2"));
+// App.WaitForElement (q => q.Marked ("Page 0"), "Timeout : Page 0");
+// App.WaitForElement (q => q.Marked ("Page 1"), "Timeout : Page 1");
+
+// var numberOfTabs = App.Query (q => q.Raw (PlatformStrings.Label + " {text BEGINSWITH 'Page'}")).Length;
+// Assert.AreEqual (2, numberOfTabs);
+
+// App.Screenshot ("Tabs reset");
+// }
+
+// [Test]
+// [Description ("Go to next tabs")]
+// public void TemplatedTabPageGalleryNextPage ()
+// {
+// TemplatedTabPageGalleryInsertTab ();
+
+// ScrollDownForQuery (q => q.Button ("Next Page: 2"));
+// App.Tap (q => q.Button ("Next Page: 2"));
+// AllElementExistForPage (0);
+// App.Screenshot ("On Page 0");
+
+// ScrollDownForQuery (q => q.Button ("Next Page: 0"));
+// App.Tap (q => q.Button ("Next Page: 0"));
+// AllElementExistForPage (1);
+// App.Screenshot ("On Page 1");
+
+// ScrollDownForQuery (q => q.Button ("Next Page: 1"));
+// App.Tap (q => q.Button ("Next Page: 1"));
+// AllElementExistForPage (2);
+// App.Screenshot ("On Page 2");
+
+// ScrollDownForQuery (q => q.Button ("Next Page: 2"));
+// App.Tap (q => q.Button ("Next Page: 2"));
+// AllElementExistForPage (0);
+// App.Screenshot ("On Page 0");
+// }
+
+// void AllElementExistForPage (int index)
+// {
+// var title = "Lorem ipsum dolor sit amet #" + index;
+
+// ScrollUpForQuery (q => q.Marked (title));
+
+// var buttons = new [] {
+// "Insert Tab: " + index,
+// "Change title: " + index,
+// "Move Tab: " + index,
+// "Remove Tab: " + index,
+// "Reset all tabs: " + index,
+// "Next Page: " + index,
+// };
+
+// App.WaitForElement (q => q.Marked (title));
+
+// foreach (var button in buttons)
+// ScrollDownForQuery (q => q.Button (button));
+
+// ScrollUpForQuery (q => q.Marked (title));
+// }
+
+// void ScrollDownForQuery (Func<AppQuery, AppQuery> query)
+// {
+// var screenBounds = App.MainScreenBounds ();
+// App.DragFromToForElement (2, query, screenBounds.Width - 10, (2 / 3.0f) * screenBounds.Height, screenBounds.Width - 10, screenBounds.Height / 3.0f);
+// }
+
+// void ScrollUpForQuery (Func<AppQuery, AppQuery> query)
+// {
+// var screenBounds = App.MainScreenBounds ();
+// App.DragFromToForElement (2, query, screenBounds.Width - 10, screenBounds.Height / 3.0f, screenBounds.Width - 10, (2 / 3.0f) * screenBounds.Height);
+// }
+
+///*******************************************************/
+///**************** Landscape tests **********************/
+///*******************************************************/
+
+// [Test]
+// [Description ("Insert tab - Landscape")]
+// public void TemplatedTabPageGalleryInsertTabLandscape ()
+// {
+// App.SetOrientationLandscape ();
+// App.Screenshot ("Rotated to Landscape");
+// TemplatedTabPageGalleryInsertTab ();
+// App.SetOrientationPortrait ();
+// App.Screenshot ("Rotated to Portrait");
+// }
+
+// [Test]
+// [Description ("Insert tab crash reproduction - Landscape")]
+// public void TemplatedTabPageGalleryInsertTabCrashLandscape ()
+// {
+// App.SetOrientationLandscape ();
+// App.Screenshot ("Rotated to Landscape");
+// TemplatedTabPageGalleryInsertTabCrash ();
+// App.SetOrientationPortrait ();
+// App.Screenshot ("Rotated to Portrait");
+// }
+
+// [Test]
+// [Description ("Change tab Title - Landscape")]
+// public void TemplatedTabPageGalleryChangeTitlesLandscape ()
+// {
+// App.SetOrientationLandscape ();
+// App.Screenshot ("Rotated to Landscape");
+// TemplatedTabPageGalleryChangeTitles ();
+// App.SetOrientationPortrait ();
+// App.Screenshot ("Rotated to Portrait");
+// }
+
+// [Test]
+// [Description ("Move tabs - Landscape")]
+// public void TemplatedTabPageGalleryMoveTabsLandscape ()
+// {
+// App.SetOrientationLandscape ();
+// App.Screenshot ("Rotated to Landscape");
+// TemplatedTabPageGalleryMoveTabs ();
+// App.SetOrientationPortrait ();
+// App.Screenshot ("Rotated to Portrait");
+// }
+
+// [Test]
+// [Description ("Remove tabs - Landscape")]
+// public void TemplatedTabPageGalleryRemoveTabLandscapes ()
+// {
+// App.SetOrientationLandscape ();
+// App.Screenshot ("Rotated to Landscape");
+// TemplatedTabPageGalleryRemoveTabs ();
+// App.SetOrientationPortrait ();
+// App.Screenshot ("Rotated to Portrait");
+// }
+
+// [Test]
+// [Description ("Add / remove tabs - Landscape")]
+// public void TemplatedTabPageGalleryAddRemoveTabsLandscape ()
+// {
+// App.SetOrientationLandscape ();
+// App.Screenshot ("Rotated to Landscape");
+// TemplatedTabPageGalleryAddRemoveTabs ();
+// App.SetOrientationPortrait ();
+// App.Screenshot ("Rotated to Portrait");
+// }
+
+// [Test]
+// [Description ("Reset tabs - Landscape")]
+// public void TemplatedTabPageGalleryResetAllTabsLandscape ()
+// {
+// App.SetOrientationLandscape ();
+// App.Screenshot ("Rotated to Landscape");
+// TemplatedTabPageGalleryResetAllTabs ();
+// App.SetOrientationPortrait ();
+// App.Screenshot ("Rotated to Portrait");
+// }
+
+// [Test]
+// [Description ("Go to next tabs - Landscape")]
+// public void TemplatedTabPageGalleryNextPageLandscape ()
+// {
+// App.SetOrientationLandscape ();
+// App.Screenshot ("Rotated to Landscape");
+// TemplatedTabPageGalleryNextPage ();
+// App.SetOrientationPortrait ();
+// App.Screenshot ("Rotated to Portrait");
+// }
+
+ }
+}
diff --git a/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-ToolbarGalleryUITests.cs b/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-ToolbarGalleryUITests.cs
new file mode 100644
index 0000000..ad00a19
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-ToolbarGalleryUITests.cs
@@ -0,0 +1,51 @@
+using NUnit.Framework;
+using Xamarin.UITest;
+
+namespace Xamarin.Forms.Core.UITests
+{
+ [TestFixture]
+ [Category ("ToolBar")]
+ internal class ToolbarGalleryTests : BaseTestFixture
+ {
+ // TODO - Is there a ToolBar item limit, test image only toolbar item
+ // TODO: Port to new conventions
+
+ public ToolbarGalleryTests ()
+ {
+ ShouldResetPerFixture = false;
+ }
+
+ protected override void NavigateToGallery ()
+ {
+ App.NavigateToGallery (GalleryQueries.ToolbarGalleryLegacy);
+ }
+
+ //void AllElementsPresent ()
+ //{
+ // var elements = new [] { "One", "Two", "Three", "Four", "Click the toolbar" };
+ // foreach (var element in elements)
+ // App.WaitForElement (q => q.Marked (element));
+
+ // App.Screenshot ("All elements exist");
+ //}
+
+ [Test]
+ public void ToolbarGalleryToolbarAction ()
+ {
+ // AllElementsPresent ();
+
+ // var elements = new [] { "One", "Two", "Three", "Four" };
+ // foreach (var element in elements) {
+ // App.Tap (q => q.Marked (element));
+ // App.WaitForElement (q => q.Marked ("Activated: " + element));
+ // }
+
+ // App.Screenshot ("Toolbar commands fire");
+ }
+
+/*******************************************************/
+/**************** Landscape tests **********************/
+/*******************************************************/
+
+ }
+}
diff --git a/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-UnevenListTests.cs b/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-UnevenListTests.cs
new file mode 100644
index 0000000..b425545
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-UnevenListTests.cs
@@ -0,0 +1,38 @@
+using NUnit.Framework;
+using Xamarin.UITest;
+using Xamarin.UITest.iOS;
+
+namespace Xamarin.Forms.Core.UITests
+{
+ [TestFixture]
+ [Category ("Cells")]
+ internal class UnevenListTests : BaseTestFixture
+ {
+ public UnevenListTests ()
+ {
+ ShouldResetPerFixture = false;
+ }
+
+ protected override void NavigateToGallery ()
+ {
+ App.NavigateToGallery (GalleryQueries.UnevenListGalleryLegacy);
+ }
+
+ [Test]
+ public void UnevenListCellTest ()
+ {
+ if (UnevenListTests.ShouldRunTest(RunningApp.App)) {
+ var element = App.Query (q => q.Marked ("unevenCellListGalleryDynamic").Descendant (("UITableViewCellContentView"))) [0];
+
+ Assert.GreaterOrEqual (element.Rect.Height, 100);
+ }
+ }
+
+ public static bool ShouldRunTest (IApp app)
+ {
+ var appAs = app as iOSApp;
+ return (appAs != null && appAs.Device.IsPhone);
+ }
+
+ }
+}
diff --git a/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-UnevenViewCellUITests.cs b/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-UnevenViewCellUITests.cs
new file mode 100644
index 0000000..1b826ec
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-UnevenViewCellUITests.cs
@@ -0,0 +1,94 @@
+using NUnit.Framework;
+using Xamarin.UITest;
+
+namespace Xamarin.Forms.Core.UITests
+{
+ [TestFixture]
+ [Category ("Cells")]
+ internal class UnevenViewCellGalleryTests : BaseTestFixture
+ {
+ // TODO
+ // TODO: Port to new conventions
+
+ public UnevenViewCellGalleryTests ()
+ {
+ ShouldResetPerFixture = false;
+ }
+
+ protected override void NavigateToGallery ()
+ {
+ App.NavigateToGallery (GalleryQueries.UnevenViewCellGalleryLegacy);
+ }
+// void AllElementsPresent ()
+// {
+// App.WaitForElement (q => q.Marked ("Testing"), "Timeout : Testing");
+// App.WaitForElement (PlatformQueries.Map, "Timeout : Map");
+// App.Screenshot ("All elements exist");
+// }
+
+ [Test]
+ [Description ("All views exist")]
+ public void UnevenViewCellGalleryScrollDownForAllElements ()
+ {
+// AllElementsPresent ();
+
+// var window = App.Query (q => q.Raw ("*")) [0];
+// var windowWidth = window.Rect.Width;
+// var windowHeight = window.Rect.Height;
+
+// App.DragFromToForElement (20, q => q.Marked ("1 day"), windowWidth - 100, windowHeight - 100, windowWidth - 100, windowHeight / 2);
+// App.DragFromToForElement (20, q => q.Marked ("2 days"), windowWidth - 100, windowHeight - 100, windowWidth - 100, windowHeight / 2);
+// App.DragFromToForElement (20, q => q.Marked ("3 days"), windowWidth - 100, windowHeight - 100, windowWidth - 100, windowHeight / 2);
+// App.DragFromToForElement (20, q => q.Marked ("4 days"), windowWidth - 100, windowHeight - 100, windowWidth - 100, windowHeight / 2);
+// App.DragFromToForElement (20, q => q.Marked ("5 days"), windowWidth - 100, windowHeight - 100, windowWidth - 100, windowHeight / 2);
+
+// App.Screenshot ("All views exist");
+ }
+
+// [Test]
+// [Description ("Check uneven ViewCell sizes")]
+// public void UnevenViewCellGalleryCheckViewCellSizes ()
+// {
+// AllElementsPresent ();
+
+// var window = App.Query (q => q.Raw ("*")) [0];
+// var windowWidth = window.Rect.Width;
+// var windowHeight = window.Rect.Height;
+
+// var unevenCellHeight = App.Query (PlatformQueries.Map) [0].Rect.Height;
+
+// App.DragFromToForElement (20, q => q.Marked ("1 day"), windowWidth - 100, windowHeight - 100, windowWidth - 100, windowHeight / 2);
+
+// var evenCellHeight = App.Query (q => q.Marked ("1 day")) [0].Rect.Height;
+
+// Assert.Greater (unevenCellHeight, evenCellHeight);
+// }
+
+///*******************************************************/
+///**************** Landscape tests **********************/
+///*******************************************************/
+
+// [Test]
+// [Description ("All views exist - Landscape")]
+// public void UnevenViewCellGalleryScrollDownForAllElementsLandscape ()
+// {
+// App.SetOrientationLandscape ();
+// App.Screenshot ("Rotated to Landscape");
+// UnevenViewCellGalleryScrollDownForAllElements ();
+// App.SetOrientationPortrait ();
+// App.Screenshot ("Rotated to Portrait");
+// }
+
+// [Test]
+// [Description ("Check uneven ViewCell sizes - Landscape")]
+// public void UnevenViewCellGalleryCheckViewCellSizesLandscape ()
+// {
+// App.SetOrientationLandscape ();
+// App.Screenshot ("Rotated to Landscape");
+// UnevenViewCellGalleryCheckViewCellSizes ();
+// App.SetOrientationPortrait ();
+// App.Screenshot ("Rotated to Portrait");
+// }
+
+ }
+}
diff --git a/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-ViewCellUITests.cs b/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-ViewCellUITests.cs
new file mode 100644
index 0000000..c6a79e7
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Tests/Legacy-ViewCellUITests.cs
@@ -0,0 +1,66 @@
+using NUnit.Framework;
+
+using Xamarin.Forms.CustomAttributes;
+using Xamarin.UITest;
+
+namespace Xamarin.Forms.Core.UITests
+{
+ [TestFixture]
+ [Category ("Cells")]
+ internal class ViewCellGalleryTests : BaseTestFixture
+ {
+// // TODO
+ // TODO: Port to new conventions
+
+ public ViewCellGalleryTests ()
+ {
+ ShouldResetPerFixture = false;
+ }
+
+ protected override void NavigateToGallery ()
+ {
+ App.NavigateToGallery (GalleryQueries.ViewCellGalleryLegacy);
+ }
+
+// public void AllElementsPresent ()
+// {
+// App.WaitForElement (q => q.Marked ("Testing"), "Timeout : Testing");
+// App.WaitForElement (q => q.Marked ("0"), "Timeout : 0");
+// App.WaitForElement (q => q.Marked ("BrandLabel"), "Timeout : BrandLabel");
+
+// App.Screenshot ("All elements exist");
+// }
+
+ [Test]
+ [UiTest (typeof(ViewCell))]
+ [Description ("All elements exist")]
+ public void ViewCellGalleryScrollDownForAllElements ()
+ {
+// AllElementsPresent ();
+
+// App.ScrollForElement ("* marked:'0'", new Drag (ScreenBounds, Drag.Direction.BottomToTop, Drag.DragLength.Medium));
+// App.ScrollForElement ("* marked:'1'", new Drag (ScreenBounds, Drag.Direction.BottomToTop, Drag.DragLength.Medium));
+// App.ScrollForElement ("* marked:'2'", new Drag (ScreenBounds, Drag.Direction.BottomToTop, Drag.DragLength.Medium));
+// App.ScrollForElement ("* marked:'3'", new Drag (ScreenBounds, Drag.Direction.BottomToTop, Drag.DragLength.Medium));
+// App.ScrollForElement ("* marked:'4'", new Drag (ScreenBounds, Drag.Direction.BottomToTop, Drag.DragLength.Medium));
+
+// App.Screenshot ("All ViewCells exist");
+ }
+
+///*******************************************************/
+///**************** Landscape tests **********************/
+///*******************************************************/
+
+// [Test]
+// [Description ("All elements exist - Landscape")]
+// public void ViewCellGalleryScrollDownForAllElementsLandscape ()
+// {
+// App.SetOrientationLandscape ();
+// App.Screenshot ("Rotated to Landscape");
+// ViewCellGalleryScrollDownForAllElements ();
+// App.SetOrientationPortrait ();
+// App.Screenshot ("Rotated to Portrait");
+// }
+
+ }
+}
diff --git a/Xamarin.Forms.Core.iOS.UITests/Tests/PickerUITests.cs b/Xamarin.Forms.Core.iOS.UITests/Tests/PickerUITests.cs
new file mode 100644
index 0000000..19357fa
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Tests/PickerUITests.cs
@@ -0,0 +1,54 @@
+using System;
+using System.CodeDom;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Security.Cryptography;
+using System.Threading;
+using System.Reflection;
+
+using NUnit.Framework;
+
+using Xamarin.Forms.CustomAttributes;
+using Xamarin.UITest.Android;
+using Xamarin.UITest.Queries;
+using Xamarin.UITest.iOS;
+
+namespace Xamarin.Forms.Core.UITests
+{
+ [TestFixture]
+ [Category ("Picker")]
+ internal class PickerUITests : _ViewUITests
+ {
+ public PickerUITests ()
+ {
+ PlatformViewType = Views.Picker;
+ }
+
+ protected override void NavigateToGallery ()
+ {
+ App.NavigateToGallery (GalleryQueries.PickerGallery);
+ }
+
+ // TODO
+ public override void _Focus () {}
+
+ [UiTestExempt (ExemptReason.CannotTest, "Invalid interaction")]
+ public override void _GestureRecognizers () {}
+
+ // TODO
+ public override void _IsFocused () {}
+
+ // TODO
+ public override void _UnFocus () {}
+
+ // TODO
+ // Implement control specific ui tests
+
+ protected override void FixtureTeardown ()
+ {
+ App.NavigateBack ();
+ base.FixtureTeardown ();
+ }
+ }
+} \ No newline at end of file
diff --git a/Xamarin.Forms.Core.iOS.UITests/Tests/ProgressBarUITests.cs b/Xamarin.Forms.Core.iOS.UITests/Tests/ProgressBarUITests.cs
new file mode 100644
index 0000000..5d95145
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Tests/ProgressBarUITests.cs
@@ -0,0 +1,56 @@
+using System;
+using System.CodeDom;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Security.Cryptography;
+using System.Threading;
+using System.Reflection;
+
+using NUnit.Framework;
+
+using Xamarin.Forms.CustomAttributes;
+using Xamarin.UITest.Android;
+using Xamarin.UITest.Queries;
+using Xamarin.UITest.iOS;
+
+namespace Xamarin.Forms.Core.UITests
+{
+ [TestFixture]
+ [Category ("ProgressBar")]
+ internal class ProgressBarUITests : _ViewUITests
+ {
+ public ProgressBarUITests ()
+ {
+ PlatformViewType = Views.ProgressBar;
+ }
+
+ protected override void NavigateToGallery ()
+ {
+ App.NavigateToGallery (GalleryQueries.ProgressBarGallery);
+ }
+
+ [UiTestExempt (ExemptReason.CannotTest, "Invalid interaction")]
+ public override void _Focus () {}
+
+ // TODO
+ public override void _GestureRecognizers () {}
+
+ [UiTestExempt (ExemptReason.CannotTest, "Invalid interaction")]
+ public override void _IsFocused () {}
+
+ [UiTestExempt (ExemptReason.CannotTest, "Invalid interaction")]
+ public override void _UnFocus () {}
+
+ // TODO
+ // Implement control specific ui tests
+
+ protected override void FixtureTeardown ()
+ {
+ App.NavigateBack ();
+ base.FixtureTeardown ();
+ }
+ [UiTestExempt (ExemptReason.CannotTest, "Invalid interaction")]
+ public override void _IsEnabled () {}
+ }
+} \ No newline at end of file
diff --git a/Xamarin.Forms.Core.iOS.UITests/Tests/RootGalleryUITests.cs b/Xamarin.Forms.Core.iOS.UITests/Tests/RootGalleryUITests.cs
new file mode 100644
index 0000000..764c3a6
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Tests/RootGalleryUITests.cs
@@ -0,0 +1,88 @@
+using NUnit.Framework;
+using Xamarin.UITest;
+
+using System;
+using System.Threading;
+using System.Collections.Generic;
+using System.Linq;
+using Xamarin.UITest.Queries;
+using Xamarin.UITest.iOS;
+
+namespace Xamarin.Forms.Core.UITests
+{
+ internal sealed class RootPageModel
+ {
+ public string ButtonId { get; private set; }
+ public string PageId { get; private set; }
+ public bool IsModal { get; private set; }
+
+ public RootPageModel (string buttonId, string pageID, bool isModal = false)
+ {
+ ButtonId = buttonId;
+ PageId = pageID;
+ IsModal = isModal;
+ }
+ }
+
+ [TestFixture]
+ [Category ("RootGallery")]
+ internal class RootGalleryUITests : BaseTestFixture
+ {
+ IEnumerable<RootPageModel> rootPages;
+
+ public RootGalleryUITests ()
+ {
+ string[] ids = {
+ "Content",
+ "Nav->Content",
+ "MDP->Nav->Content",
+ "Tab->Content",
+ "Tab->MDP->Nav->Content",
+ "Tab->Nav->Content",
+ "Tab(Many)->Nav->Content",
+ "Nav->Tab->Content(BAD IDEA)",
+ "Nav->Tab(Many)->Content(BAD IDEA)",
+ "MDP->Nav->Tab->Content(BAD IDEA)"
+ };
+ string[] modalIds = {
+ "(Modal)Content",
+ "(Modal)Nav->Content",
+ "(Modal)MDP->Nav->Content",
+ "(Modal)Tab->Content",
+ "(Modal)Tab->MDP->Nav->Content",
+ "(Modal)Tab->Nav->Content",
+ "(Modal)Tab(Many)->Nav->Content",
+ "(Modal)Nav->Tab->Content(BAD IDEA)",
+ "(Modal)Nav->Tab(Many)->Content(BAD IDEA)",
+ "(Modal)MDP->Nav->Tab->Content(BAD IDEA)",
+ };
+
+ rootPages =
+ (from id in ids
+ select new RootPageModel (id + "ButtonId", id + "PageId")).Union (
+ from id in modalIds
+ select new RootPageModel (id + "ButtonId", id + "PageId",true));
+
+ }
+
+ protected override void NavigateToGallery ()
+ {
+ App.NavigateToGallery (GalleryQueries.RootPagesGallery);
+ }
+
+ [Test]
+ [Ignore("Ignore while we dont't have a response from XTC team why this fails some times")]
+ public void VisitEachPage ()
+ {
+ foreach (var page in rootPages) {
+ var scrollViewArea = App.Query (q => q.Marked ("ChoosePageScrollView")).First ().Rect;
+ App.ScrollForElement (string.Format("* marked:'{0}'", page.ButtonId), new Drag (scrollViewArea, Drag.Direction.BottomToTop, Drag.DragLength.Long));
+ App.Tap (q => q.Marked (page.ButtonId));
+ if(!page.IsModal || App is iOSApp)
+ App.WaitForElement (q => q.Marked (page.PageId));
+ App.Screenshot ("Page: " + page.PageId);
+ }
+ }
+ }
+}
+
diff --git a/Xamarin.Forms.Core.iOS.UITests/Tests/ScrollViewUITests.cs b/Xamarin.Forms.Core.iOS.UITests/Tests/ScrollViewUITests.cs
new file mode 100644
index 0000000..ed75fa4
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Tests/ScrollViewUITests.cs
@@ -0,0 +1,68 @@
+using NUnit.Framework;
+using Xamarin.UITest;
+
+namespace Xamarin.Forms.Core.UITests
+{
+ [TestFixture]
+ [Category ("ScrollView")]
+ internal class ScrollViewGalleryTests : BaseTestFixture
+ {
+ public ScrollViewGalleryTests ()
+ {
+ }
+
+ protected override void NavigateToGallery ()
+ {
+ App.NavigateToGallery (GalleryQueries.ScrollViewGallery);
+ }
+
+ [Test]
+ [Description ("Scroll element to the start")]
+ public void ScrollToElement1Start ()
+ {
+ var scroller = App.Query (c => c.Marked ("thescroller"))[0];
+ //need to extract the contentOffset on iOS
+ App.Tap(c=> c.Marked("Start"));
+ App.WaitForElement (c => c.Marked ("the scrollto button"));
+ //Assert.Equals (App.Query (c => c.Marked ("the before")).Length, 0);
+ App.Screenshot ("Element is on the top");
+ }
+
+ [Test]
+ [Description ("Scroll element to the center")]
+ public void ScrollToElement2Center ()
+ {
+ App.Tap(c=> c.Marked("Center"));
+ App.WaitForElement (c => c.Marked ("the scrollto button"));
+ App.WaitForElement (c => c.Marked ("the before"));
+ App.WaitForElement (c => c.Marked ("the after"));
+ App.Screenshot ("Element is in the center");
+ }
+
+ [Test]
+ [Description ("Scroll element to the end")]
+ public void ScrollToElement3End ()
+ {
+ App.Tap(c=> c.Marked("End"));
+ App.WaitForElement (c => c.Marked ("the scrollto button"));
+ //Assert.Equals (App.Query (c => c.Marked ("the after")).Length, 0);
+ App.Screenshot ("Element is in the end");
+ }
+
+ [Test]
+ [Description ("ScrollTo Y = 100")]
+ public void ScrollToY ()
+ {
+ App.Tap(c=> c.Marked("Scroll to 100"));
+ }
+
+ [Test]
+ [Description ("ScrollTo Y = 100 no animation")]
+ public void ScrollToYNoAnim ()
+ {
+ App.ScrollDown ();
+ App.ScrollDown ();
+ App.Tap (c => c.Marked ("Scroll to 100 no anim"));
+ }
+ }
+}
diff --git a/Xamarin.Forms.Core.iOS.UITests/Tests/SearchBarUITests.cs b/Xamarin.Forms.Core.iOS.UITests/Tests/SearchBarUITests.cs
new file mode 100644
index 0000000..e45ba38
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Tests/SearchBarUITests.cs
@@ -0,0 +1,54 @@
+using System;
+using System.CodeDom;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Security.Cryptography;
+using System.Threading;
+using System.Reflection;
+
+using NUnit.Framework;
+
+using Xamarin.Forms.CustomAttributes;
+using Xamarin.UITest.Android;
+using Xamarin.UITest.Queries;
+using Xamarin.UITest.iOS;
+
+namespace Xamarin.Forms.Core.UITests
+{
+ [TestFixture]
+ [Category ("SearchBar")]
+ internal class SearchBarUITests : _ViewUITests
+ {
+ public SearchBarUITests ()
+ {
+ PlatformViewType = Views.SearchBar;
+ }
+
+ protected override void NavigateToGallery ()
+ {
+ App.NavigateToGallery (GalleryQueries.SearchBarGallery);
+ }
+
+ // TODO
+ public override void _Focus () {}
+
+ [UiTestExempt (ExemptReason.CannotTest, "Invalid interaction")]
+ public override void _GestureRecognizers () {}
+
+ // TODO
+ public override void _IsFocused () {}
+
+ // TODO
+ public override void _UnFocus () {}
+
+ // TODO
+ // Implement control specific ui tests
+
+ protected override void FixtureTeardown ()
+ {
+ App.NavigateBack ();
+ base.FixtureTeardown ();
+ }
+ }
+} \ No newline at end of file
diff --git a/Xamarin.Forms.Core.iOS.UITests/Tests/SliderUITests.cs b/Xamarin.Forms.Core.iOS.UITests/Tests/SliderUITests.cs
new file mode 100644
index 0000000..6f8eb77
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Tests/SliderUITests.cs
@@ -0,0 +1,54 @@
+using System;
+using System.CodeDom;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Security.Cryptography;
+using System.Threading;
+using System.Reflection;
+
+using NUnit.Framework;
+
+using Xamarin.Forms.CustomAttributes;
+using Xamarin.UITest.Android;
+using Xamarin.UITest.Queries;
+using Xamarin.UITest.iOS;
+
+namespace Xamarin.Forms.Core.UITests
+{
+ [TestFixture]
+ [Category ("Slider")]
+ internal class SliderUITests : _ViewUITests
+ {
+ public SliderUITests ()
+ {
+ PlatformViewType = Views.Slider;
+ }
+
+ protected override void NavigateToGallery ()
+ {
+ App.NavigateToGallery (GalleryQueries.SliderGallery);
+ }
+
+ [UiTestExempt (ExemptReason.CannotTest, "Invalid interaction")]
+ public override void _Focus () {}
+
+ // TODO
+ public override void _GestureRecognizers () {}
+
+ [UiTestExempt (ExemptReason.CannotTest, "Invalid interaction")]
+ public override void _IsFocused () {}
+
+ [UiTestExempt (ExemptReason.CannotTest, "Invalid interaction")]
+ public override void _UnFocus () {}
+
+ // TODO
+ // Implement control specific ui tests
+
+ protected override void FixtureTeardown ()
+ {
+ App.NavigateBack ();
+ base.FixtureTeardown ();
+ }
+ }
+} \ No newline at end of file
diff --git a/Xamarin.Forms.Core.iOS.UITests/Tests/StepperUITests.cs b/Xamarin.Forms.Core.iOS.UITests/Tests/StepperUITests.cs
new file mode 100644
index 0000000..bec1e22
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Tests/StepperUITests.cs
@@ -0,0 +1,54 @@
+using System;
+using System.CodeDom;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Security.Cryptography;
+using System.Threading;
+using System.Reflection;
+
+using NUnit.Framework;
+
+using Xamarin.Forms.CustomAttributes;
+using Xamarin.UITest.Android;
+using Xamarin.UITest.Queries;
+using Xamarin.UITest.iOS;
+
+namespace Xamarin.Forms.Core.UITests
+{
+ [TestFixture]
+ [Category ("Stepper")]
+ internal class StepperUITests : _ViewUITests
+ {
+ public StepperUITests ()
+ {
+ PlatformViewType = Views.Stepper;
+ }
+
+ protected override void NavigateToGallery ()
+ {
+ App.NavigateToGallery (GalleryQueries.StepperGallery);
+ }
+
+ [UiTestExempt (ExemptReason.CannotTest, "Invalid interaction")]
+ public override void _Focus () {}
+
+ // TODO
+ public override void _GestureRecognizers () {}
+
+ [UiTestExempt (ExemptReason.CannotTest, "Invalid interaction")]
+ public override void _IsFocused () {}
+
+ [UiTestExempt (ExemptReason.CannotTest, "Invalid interaction")]
+ public override void _UnFocus () {}
+
+ // TODO
+ // Implement control specific ui tests
+
+ protected override void FixtureTeardown ()
+ {
+ App.NavigateBack ();
+ base.FixtureTeardown ();
+ }
+ }
+} \ No newline at end of file
diff --git a/Xamarin.Forms.Core.iOS.UITests/Tests/SwitchUITests.cs b/Xamarin.Forms.Core.iOS.UITests/Tests/SwitchUITests.cs
new file mode 100644
index 0000000..344aae4
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Tests/SwitchUITests.cs
@@ -0,0 +1,54 @@
+using System;
+using System.CodeDom;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Security.Cryptography;
+using System.Threading;
+using System.Reflection;
+
+using NUnit.Framework;
+
+using Xamarin.Forms.CustomAttributes;
+using Xamarin.UITest.Android;
+using Xamarin.UITest.Queries;
+using Xamarin.UITest.iOS;
+
+namespace Xamarin.Forms.Core.UITests
+{
+ [TestFixture]
+ [Category ("Switch")]
+ internal class SwitchUITests : _ViewUITests
+ {
+ public SwitchUITests ()
+ {
+ PlatformViewType = Views.Switch;
+ }
+
+ protected override void NavigateToGallery ()
+ {
+ App.NavigateToGallery (GalleryQueries.SwitchGallery);
+ }
+
+ [UiTestExempt (ExemptReason.CannotTest, "Invalid interaction")]
+ public override void _Focus () {}
+
+ // TODO
+ public override void _GestureRecognizers () {}
+
+ [UiTestExempt (ExemptReason.CannotTest, "Invalid interaction")]
+ public override void _IsFocused () {}
+
+ [UiTestExempt (ExemptReason.CannotTest, "Invalid interaction")]
+ public override void _UnFocus () {}
+
+ // TODO
+ // Implement control specific ui tests
+
+ protected override void FixtureTeardown ()
+ {
+ App.NavigateBack ();
+ base.FixtureTeardown ();
+ }
+ }
+} \ No newline at end of file
diff --git a/Xamarin.Forms.Core.iOS.UITests/Tests/TimePickerUITests.cs b/Xamarin.Forms.Core.iOS.UITests/Tests/TimePickerUITests.cs
new file mode 100644
index 0000000..63e6a29
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Tests/TimePickerUITests.cs
@@ -0,0 +1,56 @@
+using System;
+using System.CodeDom;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Security.Cryptography;
+using System.Threading;
+using System.Reflection;
+
+using NUnit.Framework;
+
+using Xamarin.Forms.CustomAttributes;
+using Xamarin.UITest.Android;
+using Xamarin.UITest.Queries;
+using Xamarin.UITest.iOS;
+
+namespace Xamarin.Forms.Core.UITests
+{
+ [TestFixture]
+ [Category ("TimePicker")]
+ internal class TimePickerUITests : _ViewUITests
+ {
+ public TimePickerUITests ()
+ {
+ PlatformViewType = Views.TimePicker;
+ }
+
+ protected override void NavigateToGallery ()
+ {
+ App.NavigateToGallery (GalleryQueries.TimePickerGallery);
+
+ Thread.Sleep (4000);
+ }
+
+ // TODO
+ public override void _Focus () {}
+
+ [UiTestExempt (ExemptReason.CannotTest, "Invalid interaction")]
+ public override void _GestureRecognizers () {}
+
+ // TODO
+ public override void _IsFocused () {}
+
+ // TODO
+ public override void _UnFocus () {}
+
+ // TODO
+ // Implement control specific ui tests
+
+ protected override void FixtureTeardown ()
+ {
+ App.NavigateBack ();
+ base.FixtureTeardown ();
+ }
+ }
+} \ No newline at end of file
diff --git a/Xamarin.Forms.Core.iOS.UITests/Tests/ToolbarItemTests.cs b/Xamarin.Forms.Core.iOS.UITests/Tests/ToolbarItemTests.cs
new file mode 100644
index 0000000..ce846db
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Tests/ToolbarItemTests.cs
@@ -0,0 +1,102 @@
+using System;
+using NUnit.Framework;
+using Xamarin.Forms.CustomAttributes;
+using Xamarin.UITest.Android;
+using Xamarin.UITest.iOS;
+
+namespace Xamarin.Forms.Core.UITests
+{
+ [TestFixture]
+ [Category ("ToolbarItem")]
+ internal class ToolbarItemTests : BaseTestFixture
+ {
+ string btn1Id = "tb1";
+ string btn4Id = "tb4";
+
+ static bool isSecondaryMenuOpen = false;
+ static void ShouldShowMenu ()
+ {
+ if (App is AndroidApp) {
+ isSecondaryMenuOpen = true;
+ //show secondary menu
+ App.Tap (c => c.Class ("android.support.v7.widget.ActionMenuPresenter$OverflowMenuButton"));
+ }
+ }
+
+ static void ShouldHideMenu ()
+ {
+ if (App is AndroidApp && isSecondaryMenuOpen) {
+ isSecondaryMenuOpen = false;
+ App.Back ();
+ }
+ }
+
+ protected override void NavigateToGallery ()
+ {
+ App.NavigateToGallery (GalleryQueries.ToolbarItemGallery);
+ if (App is iOSApp) {
+ btn1Id = "menuIcon";
+ btn4Id = "tb4";
+ }
+ }
+
+ [Test]
+ public void ToolbarButtonsClick ()
+ {
+ ShouldHideMenu ();
+ App.Tap (c => c.Marked (btn1Id));
+ }
+
+ [Test]
+ public void ToolbarButtonsCommand ()
+ {
+ ShouldShowMenu ();
+ if (App is AndroidApp) {
+ var btn = App.Query (c => c.Marked (btn4Id))[0];
+ }
+ else {
+ App.Tap (c => c.Marked (btn4Id));
+ }
+ }
+
+ [Test]
+ public void ToolbarButtonsDisable ()
+ {
+ ShouldHideMenu ();
+ var btn1 = App.Query (c => c.Marked (btn1Id)) [0];
+ ShouldShowMenu ();
+ var btn2 = App.Query (c => c.Marked (btn4Id)) [0];
+ Assert.False (btn1.Enabled, "Toolbar Item should be disable");
+ //TODO: how to check Enable for the textview
+ //Assert.False (btn2.Enabled, "Toolbar Item should be disable");
+ }
+
+ [Test]
+ public void ToolbarButtonsExist ()
+ {
+ ShouldHideMenu ();
+ var existsPrimary = App.Query (c => c.Marked (btn1Id)).Length;
+ var existsPrimary2 = App.Query (c => c.Marked ("tb2")).Length;
+ ShouldShowMenu ();
+ var existsSecondary = App.Query (c => c.Marked ("tb3")).Length;
+ var existsSecondary2 = App.Query (c => c.Marked (btn4Id)).Length;
+ Assert.True (existsPrimary > 0, "Toolbar Item 1 no name, not found");
+ Assert.True (existsPrimary2 > 0, "Toolbar Item 2, not found");
+ Assert.True (existsSecondary > 0, "Toolbar Item 1 no name, not found");
+ Assert.True (existsSecondary2 > 0, "Toolbar Item 1, not found");
+ }
+
+ [Test]
+ public void ToolbarButtonsOrder ()
+ {
+ ShouldHideMenu ();
+ var btn1 = App.Query (c => c.Marked (btn1Id)) [0];
+ ShouldShowMenu ();
+ var btn2 = App.Query (c => c.Marked ("tb4")) [0];
+ if(App is iOSApp)
+ Assert.True (btn1.Rect.CenterY < btn2.Rect.CenterY);
+ }
+
+ }
+}
+
diff --git a/Xamarin.Forms.Core.iOS.UITests/Tests/ViewUITests.cs b/Xamarin.Forms.Core.iOS.UITests/Tests/ViewUITests.cs
new file mode 100644
index 0000000..a11d1f6
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Tests/ViewUITests.cs
@@ -0,0 +1,257 @@
+using System;
+using System.Diagnostics;
+using System.Linq;
+using System.Net.Configuration;
+
+using NUnit.Framework;
+
+using Xamarin.Forms.CustomAttributes;
+using Xamarin.UITest.Android;
+using Xamarin.UITest.iOS;
+
+namespace Xamarin.Forms.Core.UITests
+{
+ internal abstract class _ViewUITests : BaseTestFixture
+ {
+ /* Under score prefixes ensure inherited properties run first in test suite */
+ //[Test]
+ //[Category ("View")]
+ //[UiTestBroken (BrokenReason.UITestBug, "Issue #115 - when trying to get anchorPoint, iOS")]
+ //[UiTest (Test.VisualElement.AnchorX)]
+ public virtual void _AnchorX ()
+ {
+ //var remote = RemoteFactory.CreateRemote<StateViewContainerRemote> (App, "AnchorX", PlatformViewType);
+ //remote.GoTo ();
+
+ ////App.LogPropertiesForView (remote.ViewQuery, true);
+
+ //if (App is AndroidApp) {
+ // var anchorX = remote.GetProperty<float> (View.AnchorXProperty);
+ // var viewWidth = remote.GetView ().Rect.Width;
+ // Assert.AreEqual (anchorX, 0.25 * viewWidth);
+ //} else if (App is iOSApp) {
+ // var anchorXMatrix = remote.GetProperty<Matrix> (View.AnchorXProperty);
+ // var viewWidth = remote.GetView ().Rect.Width;
+ // Assert.AreEqual (anchorXMatrix.M30, 0 - (viewWidth * 0.25f));
+ //}
+ }
+
+ // [Test]
+ // [UiTest (Test.VisualElement.AnchorY)]
+ // TODO: working on some views, others not
+ public virtual void _AnchorY ()
+ {
+ //var remote = RemoteFactory.CreateRemote<StateViewContainerRemote> (App, "AnchorY", PlatformViewType);
+ //remote.GoTo ();
+
+ //if (App is AndroidApp) {
+ // var anchorY = remote.GetProperty<float> (View.AnchorYProperty);
+ // var viewHeight = remote.GetView ().Rect.Height;
+ // Assert.AreEqual (anchorY, viewHeight);
+ //} else if (App is iOSApp) {
+ // var anchorYMatrix = remote.GetProperty<Matrix> (View.AnchorYProperty);
+ // var viewHeight = remote.GetView ().Rect.Height;
+ // Assert.AreEqual (anchorYMatrix.M31, viewHeight / 2.0f);
+ //}
+ }
+
+ // [Test]
+ // [UiTest (Test.VisualElement.BackgroundColor)]
+ // [UiTestBroken (BrokenReason.UITestBug, "UITest Issue #107")]
+ public virtual void _BackgroundColor ()
+ {
+ //TODO: this was failing and is changing in next version of calabash (UI-Test-pre nuget) to a json rgb
+// var remote = RemoteFactory.CreateRemote<ViewContainerRemote> (App, "BackgroundColor", PlatformViewType);
+// remote.GoTo ();
+// if (App is iOSApp) {
+// var backgroundColor = remote.GetProperty<Color> (View.BackgroundColorProperty);
+// Assert.AreEqual (Color.Blue, backgroundColor);
+// }
+
+ }
+
+ [Test]
+ [UiTest (typeof(VisualElement), "Focus")]
+ public abstract void _Focus ();
+
+ [Test]
+ [UiTest (typeof (VisualElement), "GestureRecognizers")]
+ public abstract void _GestureRecognizers ();
+
+ //[Test]
+ [UiTest (typeof (VisualElement), "InputTransparent")]
+ public virtual void _InputTransparent ()
+ {
+ //var remote = new LayeredViewContainerRemote (App, Test.VisualElement.InputTransparent, PlatformViewType);
+ //remote.GoTo ();
+
+ //var hiddenButtonClickedLabelTextPre = remote.GetLayeredLabel ().Text;
+ //Assert.AreEqual ("Hidden Button (Not Clicked)", hiddenButtonClickedLabelTextPre);
+
+ //remote.TapHiddenButton ();
+
+ //var hiddenButtonClickedLabelTextPost = remote.GetLayeredLabel ().Text;
+ //var hiddenButtonClicked = hiddenButtonClickedLabelTextPost == "Hidden Button (Clicked)";
+
+ //// Allow tests to continue by dismissing DatePicker that should not show
+ //// Remove when InputTransparency works
+ //if (!hiddenButtonClicked && PlatformViewType == PlatformViews.DatePicker)
+ // remote.DismissPopOver ();
+
+ //Assert.True (hiddenButtonClicked);
+ }
+
+ [Test]
+ [UiTest (typeof (VisualElement), "IsEnabled")]
+ public virtual void _IsEnabled ()
+ {
+ var propName = Test.VisualElement.IsEnabled.ToString ();
+ var remote = new StateViewContainerRemote (App, Test.VisualElement.IsEnabled, PlatformViewType);
+ remote.GoTo ();
+
+ var enabled = remote.GetProperty<bool> (View.IsEnabledProperty);
+ Assert.IsTrue (enabled);
+
+ remote.TapStateButton ();
+
+ enabled = remote.GetProperty<bool> (View.IsEnabledProperty);
+ Assert.IsFalse (enabled);
+
+ remote.TapStateButton ();
+
+ var isEnabled = remote.GetStateLabel ().Text;
+ Assert.AreEqual ("True", isEnabled);
+
+ remote.TapStateButton ();
+
+ var isDisabled = remote.GetStateLabel ().Text;
+ Assert.AreEqual ("False", isDisabled);
+ }
+
+ [Test]
+ [UiTest (typeof (VisualElement), "IsFocused")]
+ public abstract void _IsFocused ();
+
+ [Test]
+ [UiTest (typeof (VisualElement), "IsVisible")]
+ public virtual void _IsVisible ()
+ {
+ var remote = new StateViewContainerRemote (App, Test.VisualElement.IsVisible, PlatformViewType);
+ remote.GoTo ();
+
+ var viewPre = remote.GetViews ();
+
+ Assert.AreEqual (1, viewPre.Length);
+
+ remote.TapStateButton ();
+
+ var viewPost = remote.GetViews ();
+
+ Assert.AreEqual (0, viewPost.Length);
+ }
+
+ [UiTestExemptAttribute (ExemptReason.None, "Not sure how to test at the moment")]
+ public virtual void _Layout (){}
+
+ [UiTestExemptAttribute (ExemptReason.None, "Not sure how to test at the moment")]
+ public virtual void _Navigation () {}
+
+ [Test]
+ [UiTest (typeof (VisualElement), "Opacity")]
+ public virtual void _Opacity ()
+ {
+ var remote = new ViewContainerRemote (App, Test.VisualElement.Opacity, PlatformViewType);
+ remote.GoTo ();
+
+ float opacity = -1f;
+ opacity = remote.GetProperty<float> (View.OpacityProperty);
+ Assert.AreEqual (0.5f, opacity);
+ }
+
+ [Test]
+ [UiTest (typeof(VisualElement), "Rotation")]
+ [UiTestBroken (BrokenReason.CalabashBug, "Calabash bug")]
+ public virtual void _Rotation ()
+ {
+ var remote = new ViewContainerRemote (App, Test.VisualElement.Rotation, PlatformViewType);
+ remote.GoTo ();
+
+ if (App is AndroidApp) {
+ var rotation = remote.GetProperty<float> (View.RotationProperty);
+ Assert.AreEqual (10.0f, rotation);
+ } else if (App is iOSApp) {
+ var rotationMatrix = remote.GetProperty<Matrix> (View.RotationProperty);
+ Matrix generatedMatrix = NumericExtensions.CalculateRotationMatrixForDegrees (10, Axis.Z);
+ Assert.AreEqual (generatedMatrix, rotationMatrix);
+ }
+ }
+
+ [Test]
+ [UiTest (typeof (VisualElement), "RotationX")]
+ public virtual void _RotationX ()
+ {
+ var remote = new ViewContainerRemote (App, Test.VisualElement.RotationX, PlatformViewType);
+ remote.GoTo ();
+
+ if (App is AndroidApp) {
+ var rotationX = remote.GetProperty<float> (View.RotationXProperty);
+ Assert.AreEqual (33.0f, rotationX);
+ } else if (App is iOSApp) {
+ var rotationXMatrix = remote.GetProperty<Matrix> (View.RotationXProperty);
+ Matrix matrix = NumericExtensions.CalculateRotationMatrixForDegrees (33.0f, Axis.X);
+ Assert.AreEqual (matrix, rotationXMatrix);
+ }
+ }
+
+ [Test]
+ [UiTest (typeof (VisualElement), "RotationY")]
+ public virtual void _RotationY ()
+ {
+ var remote = new ViewContainerRemote (App, Test.VisualElement.RotationY, PlatformViewType);
+ remote.GoTo ();
+
+ if (App is AndroidApp) {
+ var rotationY = remote.GetProperty<float> (View.RotationYProperty);
+ Assert.AreEqual (10.0f, rotationY);
+ } else if (App is iOSApp) {
+ var rotationYMatrix = remote.GetProperty<Matrix> (View.RotationYProperty);
+ Matrix matrix = NumericExtensions.CalculateRotationMatrixForDegrees (10.0f, Axis.Y);
+ Assert.AreEqual (matrix, rotationYMatrix);
+ }
+ }
+
+ [Test]
+ [UiTest (typeof (VisualElement), "Scale")]
+ public virtual void _Scale ()
+ {
+ var remote = new ViewContainerRemote (App, Test.VisualElement.Scale, PlatformViewType);
+ remote.GoTo ();
+
+ var scaleMatrix = remote.GetProperty<Matrix> (View.ScaleProperty);
+ Matrix generatedMatrix = NumericExtensions.BuildScaleMatrix (0.5f);
+ Assert.AreEqual (generatedMatrix, scaleMatrix);
+ }
+
+ [Test]
+ [UiTest (typeof (VisualElement), "TranslationX")]
+ [Category ("ManualReview")]
+ public virtual void _TranslationX ()
+ {
+ var remote = new ViewContainerRemote (App, Test.VisualElement.TranslationX, PlatformViewType);
+ remote.GoTo ();
+ }
+
+ [Test]
+ [UiTest (typeof (VisualElement), "TranslationY")]
+ [Category ("ManualReview")]
+ public virtual void _TranslationY ()
+ {
+ var remote = new ViewContainerRemote (App, Test.VisualElement.TranslationY, PlatformViewType);
+ remote.GoTo ();
+ }
+
+ [Test]
+ [UiTest (typeof (VisualElement), "Unfocus")]
+ public abstract void _UnFocus ();
+ }
+} \ No newline at end of file
diff --git a/Xamarin.Forms.Core.iOS.UITests/Tests/WebViewUITests.cs b/Xamarin.Forms.Core.iOS.UITests/Tests/WebViewUITests.cs
new file mode 100644
index 0000000..d4233cb
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Tests/WebViewUITests.cs
@@ -0,0 +1,93 @@
+using System;
+using System.CodeDom;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Security.Cryptography;
+using System.Threading;
+using System.Reflection;
+
+using NUnit.Framework;
+
+using Xamarin.Forms.CustomAttributes;
+using Xamarin.UITest.Android;
+using Xamarin.UITest.Queries;
+using Xamarin.UITest.iOS;
+
+namespace Xamarin.Forms.Core.UITests
+{
+ [TestFixture]
+ [Category ("WebView")]
+ internal class WebViewUITests : _ViewUITests
+ {
+ public WebViewUITests ()
+ {
+ PlatformViewType = Views.WebView;
+ }
+
+ protected override void NavigateToGallery ()
+ {
+ App.NavigateToGallery (GalleryQueries.WebViewGallery);
+ }
+
+ [Category ("ManualReview")]
+ public override void _IsEnabled ()
+ {
+ Assert.Inconclusive ("Does not make sense for WebView");
+ }
+
+ [Test]
+ [Category ("ManualReview")]
+ public override void _IsVisible () {}
+
+ [UiTestExempt (ExemptReason.CannotTest, "Invalid interaction with Label")]
+ public override void _Focus () {}
+
+ // TODO
+ public override void _GestureRecognizers () {}
+
+ [UiTestExempt (ExemptReason.CannotTest, "Invalid interaction with Label")]
+ public override void _IsFocused () {}
+
+ [Test]
+ [Category ("ManualReview")]
+ public override void _Opacity () {}
+
+ [Test]
+ [Category ("ManualReview")]
+ public override void _Rotation () {}
+
+ [Test]
+ [Category ("ManualReview")]
+ public override void _RotationX () {}
+
+ [Test]
+ [Category ("ManualReview")]
+ public override void _RotationY () {}
+
+
+ [Test]
+ [Category ("ManualReview")]
+ public override void _TranslationX () {}
+
+ [Test]
+ [Category ("ManualReview")]
+ public override void _TranslationY () {}
+
+ [Test]
+ [Category ("ManualReview")]
+ public override void _Scale () {}
+
+ [UiTestExempt (ExemptReason.CannotTest, "Invalid interaction with Label")]
+ public override void _UnFocus () {}
+
+ // TODO
+ // Implement control specific ui tests
+
+ protected override void FixtureTeardown ()
+ {
+ App.NavigateBack ();
+ base.FixtureTeardown ();
+ }
+ }
+} \ No newline at end of file
diff --git a/Xamarin.Forms.Core.iOS.UITests/Utilities/AppExtensions.cs b/Xamarin.Forms.Core.iOS.UITests/Utilities/AppExtensions.cs
new file mode 100644
index 0000000..c6f2508
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Utilities/AppExtensions.cs
@@ -0,0 +1,116 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+using NUnit.Framework;
+
+using Xamarin.UITest;
+using Xamarin.UITest.Android;
+using Xamarin.UITest.iOS;
+using Xamarin.UITest.Queries;
+using System.Text.RegularExpressions;
+
+namespace Xamarin.Forms.Core.UITests
+{
+ internal static class AppExtensions
+ {
+ public static AppRect ScreenBounds (this IApp app)
+ {
+ return app.Query (Queries.Root ()).First().Rect;
+ }
+
+ public static void NavigateBack (this IApp app)
+ {
+ app.Tap (Queries.NavigationBarBackButton ());
+ }
+
+ public static void NavigateToGallery (this IApp app, string page)
+ {
+ var text = Regex.Match (page, "'(?<text>[^']*)'").Groups["text"].Value;
+ app.EnterText (q => q.Raw ("* marked:'SearchBar'"), text);
+ //var searchBar = app.Query (q => q.Raw ("* marked:'SearchBar'")).Single ();
+ Thread.Sleep(10000);
+
+ app.Tap (q => q.Raw ("* marked:'GoToTestButton'"));
+ app.WaitForNoElement (o => o.Raw ("* marked:'GoToTestButton'"), "Timed out", TimeSpan.FromMinutes(2));
+
+ //app.Screenshot ("Navigating to gallery ...");
+ //var galleryListViewBounds = app.Query (Queries.GalleryListView)[0].Rect;
+ //app.ScrollForElement (page, new Drag (galleryListViewBounds, Drag.Direction.BottomToTop, Drag.DragLength.Long));
+ //app.Tap (q => q.Raw (page));
+ //app.Screenshot ("At gallery!");
+ }
+
+ public static void NavigateToTestCases (this IApp app, string testCase)
+ {
+ app.Tap (q => q.Button ("Go to Test Cases"));
+ app.WaitForElement (q => q.Raw ("* marked:'TestCasesIssueList'"));
+
+ app.EnterText (q => q.Raw ("* marked:'SearchBarGo'"), testCase);
+
+ app.WaitForElement (q => q.Raw ("* marked:'SearchButton'"));
+ app.Tap (q => q.Raw ("* marked:'SearchButton'"));
+
+ //app.NavigateToTestCase(testCase);
+ }
+
+ public static void NavigateToTestCase (this IApp app, string testCase)
+ {
+ string testCasesQuery = "* marked:'" + testCase + "'";
+ var testCaseIssue = app.Query (q => q.Raw ("* marked:'TestCasesIssueList'")).FirstOrDefault ();
+ if (testCaseIssue != null) {
+ AppRect scrollRect = testCaseIssue.Rect;
+ app.ScrollForElement (testCasesQuery, new Drag (scrollRect, Drag.Direction.BottomToTop, Drag.DragLength.Long));
+ app.Tap (q => q.Raw (testCasesQuery));
+ } else {
+ Debug.WriteLine (string.Format ("Failed to find test case {0}", testCase));
+ }
+ }
+
+ public static bool RectsEqual (AppRect rectOne, AppRect rectTwo)
+ {
+ const float equalsTolerance = 0.1f;
+
+ bool areEqual =
+ (Math.Abs (rectOne.X - rectTwo.X) < equalsTolerance) &&
+ (Math.Abs (rectOne.Y - rectTwo.Y) < equalsTolerance) &&
+ (Math.Abs (rectOne.Width - rectTwo.Width) < equalsTolerance) &&
+ (Math.Abs (rectOne.Height - rectTwo.Height) < equalsTolerance) &&
+ (Math.Abs (rectOne.CenterX - rectTwo.CenterX) < equalsTolerance) &&
+ (Math.Abs (rectOne.CenterY - rectTwo.CenterY) < equalsTolerance);
+
+ return areEqual;
+ }
+
+ public static void WaitForAnimating (this IApp app, Func<AppQuery, AppQuery> query)
+ {
+ // Right now only checks if bounds are moving
+ const int pollingRate = 200;
+ const int timeout = 5000;
+ var sw = new Stopwatch ();
+
+ var previousState = app.Query (query).First ().Rect;
+
+ sw.Start ();
+ while (true) {
+
+ var newState = app.Query (query).First ().Rect;
+
+ if (RectsEqual (previousState, newState))
+ break;
+
+ previousState = newState;
+
+ if (sw.ElapsedMilliseconds >= timeout)
+ throw new Exception("Timed out");
+
+ Thread.Sleep (pollingRate);
+ }
+ sw.Stop ();
+ }
+ }
+}
diff --git a/Xamarin.Forms.Core.iOS.UITests/Utilities/Drag.cs b/Xamarin.Forms.Core.iOS.UITests/Utilities/Drag.cs
new file mode 100644
index 0000000..71b1fa0
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Utilities/Drag.cs
@@ -0,0 +1,173 @@
+using System.Reflection.Emit;
+
+using Xamarin.UITest.Queries;
+
+namespace Xamarin.Forms.Core.UITests
+{
+ internal class Drag
+ {
+ internal enum DragLength
+ {
+ Long,
+ Medium,
+ Short
+ }
+
+ internal enum Direction
+ {
+ TopToBottom,
+ BottomToTop,
+ RightToLeft,
+ LeftToRight
+ }
+
+ AppRect dragBounds;
+ float xStart;
+ float yStart;
+ float xEnd;
+ float yEnd;
+ Direction dragDirection;
+ Direction oppositeDirection;
+ DragLength dragLength;
+
+ public Drag (AppRect dragbounds, float xStart, float yStart, float xEnd, float yEnd, Direction direction)
+ {
+ dragBounds = dragbounds;
+ this.xStart = xStart;
+ this.yStart = yStart;
+ this.xEnd = xEnd;
+ this.yEnd = yEnd;
+ dragDirection = direction;
+ oppositeDirection = GetOppositeDirection (direction);
+ }
+
+ public Drag (AppRect dragBounds, Direction direction, DragLength dragLength)
+ {
+ this.dragBounds = dragBounds;
+ dragDirection = direction;
+ this.dragLength = dragLength;
+ SetDragForBounds (dragDirection, dragLength);
+ }
+
+ void SetDragForBounds (Direction direction, DragLength dragLength)
+ {
+ // percentage of bounds to scroll centered in element
+ float scrollPercentage;
+
+ switch (dragLength) {
+ case DragLength.Long:
+ scrollPercentage = 0.8f;
+ break;
+ case DragLength.Medium:
+ scrollPercentage = 0.5f;
+ break;
+ default:
+ scrollPercentage = 0.2f;
+ break;
+ }
+
+ if (direction == Direction.LeftToRight) {
+ yStart = dragBounds.CenterY;
+ yEnd = dragBounds.CenterY;
+ float xDisplacement = (dragBounds.CenterX + (dragBounds.Width / 2)) - dragBounds.X;
+ float insetForScroll = (xDisplacement - (xDisplacement * scrollPercentage)) / 2;
+ xStart = dragBounds.X + insetForScroll;
+ xEnd = (dragBounds.CenterX + (dragBounds.Width / 2)) - insetForScroll;
+ } else if (direction == Direction.RightToLeft) {
+ yStart = dragBounds.CenterY;
+ yEnd = dragBounds.CenterY;
+ float xDisplacement = (dragBounds.CenterX + (dragBounds.Width / 2)) - dragBounds.X;
+ float insetForScroll = (xDisplacement - (xDisplacement * scrollPercentage)) / 2;
+ xStart = (dragBounds.CenterX + (dragBounds.Width / 2)) - insetForScroll;
+ xEnd = dragBounds.X + insetForScroll;
+ } else if (direction == Direction.TopToBottom) {
+ xStart = dragBounds.CenterX;
+ xEnd = dragBounds.CenterX;
+ float yDisplacement = (dragBounds.CenterY + (dragBounds.Height / 2)) - dragBounds.Y;
+ float insetForScroll = (yDisplacement - (yDisplacement * scrollPercentage)) / 2;
+ yStart = dragBounds.Y + insetForScroll;
+ yEnd = (dragBounds.CenterY + (dragBounds.Height / 2)) - insetForScroll;
+ } else if (direction == Direction.BottomToTop) {
+ xStart = dragBounds.CenterX;
+ xEnd = dragBounds.CenterX;
+ float yDisplacement = (dragBounds.CenterY + (dragBounds.Height / 2)) - dragBounds.Y;
+ float insetForScroll = (yDisplacement - (yDisplacement * scrollPercentage)) / 2;
+ yStart = (dragBounds.CenterY + (dragBounds.Height / 2)) - insetForScroll;
+ yEnd = dragBounds.Y + insetForScroll;
+
+ }
+ }
+
+ Direction GetOppositeDirection (Direction direction)
+ {
+ switch (direction) {
+ case Direction.TopToBottom:
+ return Direction.BottomToTop;
+ case Direction.BottomToTop:
+ return Direction.TopToBottom;
+ case Direction.RightToLeft:
+ return Direction.LeftToRight;
+ case Direction.LeftToRight:
+ return Direction.RightToLeft;
+ default:
+ return Direction.TopToBottom;
+ }
+ }
+
+ public AppRect DragBounds
+ {
+ get { return dragBounds; }
+ }
+
+ public float XStart
+ {
+ get { return xStart; }
+ }
+
+ public float YStart
+ {
+ get { return yStart; }
+ }
+
+ public float XEnd
+ {
+ get { return xEnd; }
+ }
+
+ public float YEnd
+ {
+ get { return yEnd; }
+ }
+
+ public Direction DragDirection
+ {
+ get { return dragDirection; }
+ set
+ {
+ if (dragDirection == value)
+ return;
+
+ dragDirection = value;
+ oppositeDirection = GetOppositeDirection (dragDirection);
+ OnDragDirectionChanged ();
+ }
+ }
+
+ void OnDragDirectionChanged ()
+ {
+ SetDragForBounds (dragDirection, dragLength);
+ }
+
+ public Direction OppositeDirection
+ {
+ get { return oppositeDirection; }
+ private set
+ {
+ if (oppositeDirection == value)
+ return;
+
+ oppositeDirection = value;
+ }
+ }
+ }
+} \ No newline at end of file
diff --git a/Xamarin.Forms.Core.iOS.UITests/Utilities/Gestures.cs b/Xamarin.Forms.Core.iOS.UITests/Utilities/Gestures.cs
new file mode 100644
index 0000000..548ff06
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Utilities/Gestures.cs
@@ -0,0 +1,114 @@
+using System;
+using System.Dynamic;
+using System.Linq;
+using System.Security.Cryptography;
+
+using Xamarin.UITest;
+using Xamarin.UITest.Android;
+using Xamarin.UITest.iOS;
+using Xamarin.UITest.Queries;
+
+namespace Xamarin.Forms.Core.UITests
+{
+ internal static class Gestures
+ {
+ public static bool ScrollForElement (this IApp app, string query, Drag drag, int maxSteps = 25)
+ {
+ int count = 0;
+
+ int centerTolerance = 50;
+
+ Func<AppQuery, AppQuery> elementQuery = q => q.Raw (query);
+
+ // Visible elements
+ if (app.Query (elementQuery).Length > 1) {
+ throw new UITestQueryMultipleResultsException (query);
+ }
+
+ // check to see if the element is visible already
+ if (app.Query (elementQuery).Length == 1) {
+ // centering an element whos CenterX is close to the bounding rectangle's center X can sometime register the swipe as a tap
+ float elementDistanceToDragCenter = Math.Abs (app.Query (elementQuery).First ().Rect.CenterY - drag.DragBounds.CenterY);
+ if (elementDistanceToDragCenter > centerTolerance)
+ app.CenterElementInView (elementQuery, drag.DragBounds, drag.DragDirection);
+ return true;
+ }
+
+ // loop until element is seen
+ while (app.Query (elementQuery).Length == 0 && count < maxSteps) {
+ app.DragCoordinates (drag.XStart, drag.YStart, drag.XEnd, drag.YEnd);
+ count++;
+ }
+
+ if (count != maxSteps) {
+ // centering an element whos CenterX is close to the bounding rectangle's center X can sometime register the swipe as a tap
+ float elementDistanceToDragCenter = Math.Abs (app.Query (elementQuery).First ().Rect.CenterY - drag.DragBounds.CenterY);
+ if (elementDistanceToDragCenter > centerTolerance)
+ app.CenterElementInView (elementQuery, drag.DragBounds, drag.DragDirection);
+ return true;
+ }
+
+ count = 0;
+ drag.DragDirection = drag.OppositeDirection;
+
+ while (app.Query (elementQuery).Length == 0 && count < maxSteps) {
+ app.DragCoordinates (drag.XStart, drag.YStart, drag.XEnd, drag.YEnd);
+ count++;
+ }
+
+ if (count != maxSteps) {
+ app.CenterElementInView (elementQuery, drag.DragBounds, drag.DragDirection);
+ return true;
+ }
+
+ return false;
+ }
+
+ static void CenterElementInView (this IApp app, Func<AppQuery, AppQuery> element, AppRect containingView, Drag.Direction direction)
+ {
+ // TODO Implement horizontal centering
+
+ if (direction == Drag.Direction.BottomToTop || direction == Drag.Direction.TopToBottom) {
+
+ var elementBounds = app.Query (element).First ().Rect;
+
+ bool elementCenterBelowContainerCenter = elementBounds.CenterY > containingView.CenterY;
+ bool elementCenterAboveContainerCenter = elementBounds.CenterY < containingView.CenterY;
+
+ var displacementToCenter = Math.Abs (elementBounds.CenterY - containingView.CenterY) / 2;
+
+ // avoid drag as touch
+ if (displacementToCenter < 50)
+ return;
+
+ if (elementCenterBelowContainerCenter) {
+
+ var drag = new Drag (
+ containingView,
+ containingView.CenterX, containingView.CenterY + displacementToCenter,
+ containingView.CenterX, containingView.CenterY - displacementToCenter,
+ Drag.Direction.BottomToTop
+ );
+
+ app.DragCoordinates (drag.XStart, drag.YStart, drag.XEnd, drag.YEnd);
+
+ } else if (elementCenterAboveContainerCenter) {
+
+ var drag = new Drag (
+ containingView,
+ containingView.CenterX, containingView.CenterY - displacementToCenter,
+ containingView.CenterX, containingView.CenterY + displacementToCenter,
+ Drag.Direction.TopToBottom
+ );
+
+ app.DragCoordinates (drag.XStart, drag.YStart, drag.XEnd, drag.YEnd);
+ }
+ }
+ }
+
+ public static void Pan (this IApp app, Drag drag)
+ {
+ app.DragCoordinates (drag.XStart, drag.YStart, drag.XEnd, drag.YEnd);
+ }
+ }
+} \ No newline at end of file
diff --git a/Xamarin.Forms.Core.iOS.UITests/Utilities/Logger.cs b/Xamarin.Forms.Core.iOS.UITests/Utilities/Logger.cs
new file mode 100644
index 0000000..ed0041a
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Utilities/Logger.cs
@@ -0,0 +1,71 @@
+using System;
+using System.IO;
+using System.Reflection;
+
+using Xamarin.UITest.Queries;
+
+namespace Xamarin.Forms.Core.UITests
+{
+ internal static class Logger
+ {
+ static StreamWriter queryWriter;
+
+ public static void Init ()
+ {
+ queryWriter = new StreamWriter ("../../Xamarin.Forms.Core-UITest-queries.log", false);
+ }
+
+ public static void Log (string text)
+ {
+ queryWriter.Write (text);
+ }
+
+ public static void LogLine (string text = "")
+ {
+ queryWriter.WriteLine (text);
+ }
+
+ public static void Close ()
+ {
+ queryWriter.Flush ();
+ queryWriter.Close ();
+ }
+
+ public static void LogQueryResult (AppResult[] resultsForQuery)
+ {
+ foreach (AppResult result in resultsForQuery)
+ WriteAppResult (result);
+ }
+
+ static void WriteAppResult (AppResult appResult)
+ {
+ var classText = string.Format (" {0, -10} : {1}", "Class", appResult.Class);
+ var descriptionText = string.Format (" {0, -10} : {1}", "Description", appResult.Description);
+ var enabledText = string.Format (" {0, -10} : {1}", "Enabled", appResult.Enabled);
+ var idText = string.Format (" {0, -10} : {1}", "Id", appResult.Id);
+ var labelText = string.Format (" {0, -10} : {1}", "Label", appResult.Id);
+ var textText = string.Format (" {0, -10} : {1}", "Text", appResult.Text);
+
+ var rectText = string.Format (" {0, -10}", "Rect");
+ var rectContentsText = string.Format (" [X:{0} Y:{1} W:{2} H:{3}] [CX:{4} CY:{5}]",
+ appResult.Rect.X,
+ appResult.Rect.Y,
+ appResult.Rect.Width,
+ appResult.Rect.Height,
+ appResult.Rect.CenterX,
+ appResult.Rect.CenterY
+ );
+
+ queryWriter.WriteLine (classText);
+ queryWriter.WriteLine (descriptionText);
+ queryWriter.WriteLine (enabledText);
+ queryWriter.WriteLine (idText);
+ queryWriter.WriteLine (labelText);
+ queryWriter.WriteLine (textText);
+ queryWriter.WriteLine (rectText);
+ queryWriter.WriteLine (rectContentsText);
+ queryWriter.WriteLine();
+ }
+
+ }
+} \ No newline at end of file
diff --git a/Xamarin.Forms.Core.iOS.UITests/Utilities/NumericExtensions.cs b/Xamarin.Forms.Core.iOS.UITests/Utilities/NumericExtensions.cs
new file mode 100644
index 0000000..13a4b2b
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Utilities/NumericExtensions.cs
@@ -0,0 +1,126 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Runtime.Remoting.Messaging;
+
+using NUnit.Framework;
+
+using Xamarin.UITest;
+using Xamarin.UITest.Queries;
+using Xamarin.UITest.Android;
+using Xamarin.UITest.iOS;
+using System.Globalization;
+
+namespace Xamarin.Forms.Core.UITests
+{
+ internal class Matrix : Object
+ {
+ public double M00, M01, M02, M03;
+ public double M10, M11, M12, M13;
+ public double M20, M21, M22, M23;
+ public double M30, M31, M32, M33;
+
+ public void Log () {
+
+ //Logger.LogLine ();
+
+ //Logger.LogLine (string.Format ("{0,-3}, {1,-3}, {2,-3}, {3,-3}", M00, M01, M02, M03));
+ //Logger.LogLine (string.Format ("{0,-3}, {1,-3}, {2,-3}, {3,-3}", M10, M11, M12, M13));
+ //Logger.LogLine (string.Format ("{0,-3}, {1,-3}, {2,-3}, {3,-3}", M20, M21, M22, M23));
+ //Logger.LogLine (string.Format ("{0,-3}, {1,-3}, {2,-3}, {3,-3}", M30, M31, M32, M33));
+
+ //Logger.LogLine ();
+ }
+
+ public override bool Equals (object obj)
+ {
+ if (obj == null)
+ return false;
+
+ var transform = obj as Matrix;
+ if ((Object)transform == null)
+ return false;
+
+ const double tolerance = 0.01;
+ bool result =
+ Math.Abs (M00 - transform.M00) < tolerance &&
+ Math.Abs (M01 - transform.M01) < tolerance &&
+ Math.Abs (M02 - transform.M02) < tolerance &&
+ Math.Abs (M03 - transform.M03) < tolerance &&
+ Math.Abs (M10 - transform.M10) < tolerance &&
+ Math.Abs (M11 - transform.M11) < tolerance &&
+ Math.Abs (M12 - transform.M12) < tolerance &&
+ Math.Abs (M13 - transform.M13) < tolerance &&
+ Math.Abs (M20 - transform.M20) < tolerance &&
+ Math.Abs (M21 - transform.M21) < tolerance &&
+ Math.Abs (M22 - transform.M22) < tolerance &&
+ Math.Abs (M23 - transform.M23) < tolerance &&
+ Math.Abs (M30 - transform.M30) < tolerance &&
+ Math.Abs (M31 - transform.M31) < tolerance &&
+ Math.Abs (M32 - transform.M32) < tolerance &&
+ Math.Abs (M33 - transform.M33) < tolerance;
+
+ return result;
+ }
+
+ public override int GetHashCode ()
+ {
+ return 0;
+ }
+ }
+
+ internal enum Axis
+ {
+ X,
+ Y,
+ Z
+ }
+
+ internal static class NumericExtensions
+ {
+ public static double ToRadians(this float val)
+ {
+ return (Math.PI / 180.0) * val;
+ }
+
+ public static Matrix CalculateRotationMatrixForDegrees (float degrees, Axis rotationAxis)
+ {
+ var angle = degrees.ToRadians ();
+
+ var transform = new Matrix ();
+ if (rotationAxis == Axis.X) {
+ transform.M00 = 1; transform.M01 = 0; transform.M02 = 0; transform.M03 = 0;
+ transform.M10 = 0; transform.M11 = (float) Math.Cos (angle); transform.M12 = (float) Math.Sin (angle); transform.M13 = 0;
+ transform.M20 = 0; transform.M21 = -(float) Math.Sin (angle); transform.M22 = (float) Math.Cos (angle); transform.M23 = 0;
+ transform.M30 = 0; transform.M31 = 0; transform.M32 = 0; transform.M33 = 1;
+ } else if (rotationAxis == Axis.Y) {
+ transform.M00 = (float) Math.Cos (angle); transform.M01 = 0; transform.M02 = -(float) Math.Sin (angle); transform.M03 = 0;
+ transform.M10 = 0; transform.M11 = 1; transform.M12 = 0; transform.M13 = 0;
+ transform.M20 = (float) Math.Sin (angle); transform.M21 = 0; transform.M22 = (float) Math.Cos (angle); transform.M23 = 0;
+ transform.M30 = 0; transform.M31 = 0; transform.M32 = 0; transform.M33 = 1;
+ } else {
+ transform.M00 = (float) Math.Cos (angle); transform.M01 = (float) Math.Sin (angle); transform.M02 = 0; transform.M03 = 0;
+ transform.M10 = -(float) Math.Sin (angle); transform.M11 = (float) Math.Cos (angle); transform.M12 = 0; transform.M13 = 0;
+ transform.M20 = 0; transform.M21 = 0; transform.M22 = 1; transform.M23 = 0;
+ transform.M30 = 0; transform.M31 = 0; transform.M32 = 0; transform.M33 = 1;
+ }
+
+ return transform;
+ }
+
+ public static Matrix BuildScaleMatrix (float scale)
+ {
+ var transform = new Matrix ();
+
+ transform.M00 = scale; transform.M01 = 0; transform.M02 = 0; transform.M03 = 0;
+ transform.M10 = 0; transform.M11 = scale; transform.M12 = 0; transform.M13 = 0;
+ transform.M20 = 0; transform.M21 = 0; transform.M22 = scale; transform.M23 = 0;
+ transform.M30 = 0; transform.M31 = 0; transform.M32 = 0; transform.M33 = 1;
+
+ return transform;
+ }
+
+ }
+
+} \ No newline at end of file
diff --git a/Xamarin.Forms.Core.iOS.UITests/Utilities/ParsingUtils.cs b/Xamarin.Forms.Core.iOS.UITests/Utilities/ParsingUtils.cs
new file mode 100644
index 0000000..6598e0f
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Utilities/ParsingUtils.cs
@@ -0,0 +1,89 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Runtime.Remoting.Messaging;
+
+using NUnit.Framework;
+
+using Xamarin.UITest;
+using Xamarin.UITest.Queries;
+using Xamarin.UITest.Android;
+using Xamarin.UITest.iOS;
+using System.Globalization;
+using System.Text.RegularExpressions;
+using System.IO;
+
+namespace Xamarin.Forms.Core.UITests
+{
+
+ internal static class ParsingUtils
+ {
+ public static Font ParseUIFont (string font)
+ {
+ FontAttributes fontAttrs = FontAttributes.None;
+
+ // Logger.LogLine ("TEST PARSING");
+
+ if (font.Contains ("font-weight: bold;")) {
+ // Logger.LogLine ("Found Bold");
+ fontAttrs = FontAttributes.Bold;
+ }
+
+ return new Font ().WithAttributes (fontAttrs);
+ }
+
+ public static Color ParseUIColor (string backgroundColor)
+ {
+ var delimiters = new char[] { ' ' };
+ string[] words = backgroundColor.Split (delimiters, StringSplitOptions.RemoveEmptyEntries);
+ return new Color (double.Parse (words[1]), double.Parse (words[2]), double.Parse (words[3]), double.Parse (words[4]));
+ }
+
+ public static Point ParseCGPoint (object CGPoint) {
+ var point = new Point { X = 0, Y = 0 };
+ return point;
+ }
+
+ public static Matrix ParseCATransform3D (string CATransform3D)
+ {
+ // Logger.Log (CATransform3D);
+ char[] delimiters = { '<', ' ', '>' };
+ string[] words = CATransform3D.Split (delimiters, StringSplitOptions.RemoveEmptyEntries);
+
+ List<double> numbers = new List<double> ();
+
+ // Each number is represented by 2 blocks returned by server
+ for (int i = 0; i < (words.Length - 1); i += 2) {
+ string word = words[i] + words[i + 1];
+ var number = Int64.Parse (word, NumberStyles.HexNumber);
+ byte[] bytes = BitConverter.GetBytes (number);
+ byte[] reversedBytes = bytes.Reverse ().ToArray ();
+ double value = BitConverter.ToDouble (reversedBytes, 0);
+ numbers.Add (value);
+ }
+
+ var transformationMatrix = new Matrix ();
+ transformationMatrix.M00 = numbers[0];
+ transformationMatrix.M01 = numbers[1];
+ transformationMatrix.M02 = numbers[2];
+ transformationMatrix.M03 = numbers[3];
+ transformationMatrix.M10 = numbers[4];
+ transformationMatrix.M11 = numbers[5];
+ transformationMatrix.M12 = numbers[6];
+ transformationMatrix.M13 = numbers[7];
+ transformationMatrix.M20 = numbers[8];
+ transformationMatrix.M21 = numbers[9];
+ transformationMatrix.M22 = numbers[10];
+ transformationMatrix.M23 = numbers[11];
+ transformationMatrix.M30 = numbers[12];
+ transformationMatrix.M31 = numbers[13];
+ transformationMatrix.M32 = numbers[14];
+ transformationMatrix.M33 = numbers[15];
+
+ return transformationMatrix;
+ }
+
+ }
+
+} \ No newline at end of file
diff --git a/Xamarin.Forms.Core.iOS.UITests/Utilities/UITestCustomExceptions.cs b/Xamarin.Forms.Core.iOS.UITests/Utilities/UITestCustomExceptions.cs
new file mode 100644
index 0000000..6969ac5
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Utilities/UITestCustomExceptions.cs
@@ -0,0 +1,101 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+using Xamarin.UITest.Queries;
+using System.Runtime.CompilerServices;
+
+namespace Xamarin.Forms.Core.UITests
+{
+ internal class UITestQueryNoResultException : Exception
+ {
+ readonly string message;
+
+ public UITestQueryNoResultException (string query)
+ {
+ message = string.Format ("Found no elements for query with target: {0}", query);
+ }
+
+ public override string Message
+ {
+ get { return message; }
+ }
+ }
+
+ internal class UITestQuerySingleResultException : Exception
+ {
+ readonly string message;
+
+ public UITestQuerySingleResultException (string query)
+ {
+ message = string.Format ("Found single element for query with target: {0}", query);
+ }
+
+ public override string Message
+ {
+ get { return message; }
+ }
+ }
+
+ internal class UITestQueryMultipleResultsException : Exception
+ {
+ readonly string message;
+
+ public UITestQueryMultipleResultsException (string query)
+ {
+ message = string.Format ("Found muliple elements for query with target: {0}", query);
+ }
+
+ public override string Message
+ {
+ get { return message; }
+ }
+ }
+
+ internal class UITestRemoteException : Exception
+ {
+ readonly string message;
+
+ public UITestRemoteException (string message)
+ {
+ this.message = message;
+ }
+
+ public override string Message
+ {
+ get { return message; }
+ }
+ }
+
+ internal class UITestRemoteQueryException : Exception
+ {
+ readonly string message;
+
+ public UITestRemoteQueryException (string query)
+ {
+ message = string.Format ("Error for query with target: {0}", query);
+ }
+
+ public override string Message
+ {
+ get { return message; }
+ }
+ }
+
+ internal class UITestErrorException : Exception
+ {
+ readonly string message;
+
+ public UITestErrorException (string message, [CallerMemberName] string caller = null)
+ {
+ message = string.Format ("Test error: {0}, {1}", caller, message);
+ }
+
+ public override string Message
+ {
+ get { return message; }
+ }
+ }
+}
diff --git a/Xamarin.Forms.Core.iOS.UITests/Utilities/ViewInspector.cs b/Xamarin.Forms.Core.iOS.UITests/Utilities/ViewInspector.cs
new file mode 100644
index 0000000..288ee3d
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Utilities/ViewInspector.cs
@@ -0,0 +1,342 @@
+using System;
+using System.Collections.Generic;
+
+using Xamarin.UITest;
+using Xamarin.UITest.Android;
+using Xamarin.UITest.iOS;
+using System.Linq;
+
+namespace Xamarin.Forms.Core.UITests
+{
+ internal static class ViewInspector
+ {
+ public static void LogPropertiesForView (this IApp app, string query, bool isOnParent = false)
+ {
+ if (app is AndroidApp) {
+ LogPropertiesForAndroidView ((AndroidApp)app, query, isOnParent);
+ } else {
+ LogPropertiesForUIView ((iOSApp)app, query, isOnParent);
+ LogPropertiesForCALayer ((iOSApp)app, query, isOnParent);
+ }
+ }
+
+ static void LogPropertiesForUIView (this iOSApp app, string query, bool isOnParent = false) {
+
+ //Logger.LogLine ("--- UIView Properties ---");
+
+ var properties = new [] {
+ // just getters with no params, bools
+ "alpha",
+ "autoresizesSubviews",
+ "autoresizingMask",
+ "backgroundColor",
+ "bounds",
+ "center",
+ "clearsContextBeforeDrawing",
+ "clipsToBounds",
+ "contentMode",
+ "contentScaleFactor",
+ "exclusiveTouch",
+ "frame",
+ "gestureRecognizers",
+ "hidden",
+ "layer",
+ "motionEffects",
+ "multipleTouchEnabled",
+ "opaque",
+ "restorationIdentifier",
+ "subviews",
+ "superview",
+ "tag",
+ "tintAdjustmentMode",
+ "tintColor",
+ "transform",
+ "userInteractionEnabled",
+ "window"
+ };
+
+ if (isOnParent)
+ query = query + " parent * index:0";
+
+ foreach (var property in properties) {
+ object prop;
+ bool found =
+ MaybeGetProperty<string> (app, query, property, out prop) ||
+ MaybeGetProperty<int> (app, query, property, out prop) ||
+ MaybeGetProperty<float> (app, query, property, out prop) ||
+ MaybeGetProperty<bool> (app, query, property, out prop);
+
+ //if (found)
+ // Logger.LogLine (string.Format ("{0,-30}: {1}", property, prop));
+ }
+
+ //Logger.LogLine();
+
+ }
+
+ static void LogPropertiesForCALayer(this iOSApp app, string query, bool isOnParent = false)
+ {
+ // Logger.LogLine ("--- UIView.Layer Properties ---");
+
+ var properties = new[] {
+ "actions",
+ "anchorPoint",
+ "anchorPointZ",
+ "backgroundColor",
+ "backgroundFilters",
+ "borderColor",
+ "borderWidth",
+ "bounds",
+ "compositingFilter",
+ "contents",
+ "contentsCenter",
+ "contentsGravity",
+ "contentsRect",
+ "contentsScale",
+ "cornerRadius",
+ "delegate",
+ "doubleSided",
+ "drawsAsynchronously",
+ "edgeAntialiasingMask",
+ "filters",
+ "frame",
+ "geometryFlipped",
+ "hidden",
+ "magnificationFilter",
+ "mask",
+ "masksToBounds",
+ "minificationFilter",
+ "minificationFilterBias",
+ "name",
+ "needsDisplayOnBoundsChange",
+ "opacity",
+ "opaque",
+ "position",
+ "rasterizationScale",
+ "shadowColor",
+ "shadowOffset",
+ "shadowOpacity",
+ "shadowPath",
+ "shadowRadius",
+ "shouldRasterize",
+ "style",
+ "sublayers",
+ "sublayerTransform",
+ "superlayer",
+ "transform",
+ "visibleRect",
+ "zPosition"
+ };
+
+ if (isOnParent)
+ query = query + " parent * index:0";
+
+ foreach (var property in properties)
+ {
+ object prop;
+ bool found =
+ MaybeGetLayerProperty<string>(app, query, property, out prop) ||
+ MaybeGetLayerProperty<int>(app, query, property, out prop) ||
+ MaybeGetLayerProperty<bool>(app, query, property, out prop);
+
+ //if (found)
+ // Logger.LogLine(string.Format("{0,-30}: {1}", property, prop));
+ }
+
+ //Logger.LogLine();
+
+ }
+
+ static void LogPropertiesForAndroidView (this AndroidApp app, string query, bool isOnParent = false)
+ {
+ // Logger.LogLine( "--- Android View Properties ---");
+
+ var properties = new [] {
+ // just getters with no params, bools
+ //"getAccessibilityLiveRegion",
+ //"getAccessibilbityNodeProvider",
+ //"getAlpha",
+ //"getAnimation",
+ //"getApplicationWindowToken",
+ //"getBackground",
+ //"getBaseline",
+ //"getBottom",
+ //"getCameraDistance",
+ //"getClipBounds",
+ //"getContentDescription",
+ //"getContext",
+ //"getDefaultSize",
+ //"getDisplay",
+ //"getDrawableState",
+ //"getDrawingCache",
+ //"getDrawingCacheBackgroundColor",
+ //"getDrawingRect",
+ //"getDrawingTime",
+ //"getFilterTouchesWhenObscurred",
+ //"getFitsSystemWindows",
+ //"getFocusables",
+ //"getHandler",
+ //"getHeight",
+ //"getHitRect",
+ //"getHorizontalFadingEdgeLength",
+ //"getId",
+ //"getImportantForAccessibility",
+ //"getKeepScreenOn",
+ //"getKeyDispatcherState",
+ //"getLabelFor",
+ //"getLayerType",
+ //"getLayoutDirection",
+ //"getLayourParams",
+ //"getLeft",
+ "getMatrix",
+ //"getMeasuredHeight",
+ //"getMeasuredHeightAndState",
+ //"getMeasuredState",
+ //"getMeasuredWidth",
+ //"getMeasuredWidthAndState",
+ //"getMinimumHeight",
+ //"getMinimumWidth",
+ //"getNextFocusDownId",
+ //"getNextFocusForwardId",
+ //"getNextFocusLeftId",
+ //"getNextFocusRightId",
+ //"getNextFocusUpId",
+ //"getOnFocusChangedListener",
+ //"getOverScrollMethod",
+ //"getOverlay",
+ //"getPaddingBottom",
+ //"getPaddingEnd",
+ //"getPaddingLeft",
+ //"getPaddingRight",
+ //"getPaddingStart",
+ //"getPaddingTop",
+ //"getParent",
+ //"getParentForAccessibility",
+ //"getPivotX",
+ //"getPivotY",
+ //"getResources",
+ //"getRight",
+ //"getRootView",
+ //"getRotation",
+ //"getRotationX",
+ //"getRotationY",
+ "getScaleX",
+ "getScaleY",
+ //"getScrollBarDefaultDelayBeforeFade",
+ //"getScrollBarFadeDuration",
+ //"getScrollBarSize",
+ //"getScrollBarStyle",
+ //"getScrollX",
+ //"getScrollY",
+ //"getSolidColor",
+ //"getSystemUiVisibility",
+ //"getTag",
+ //"getTextAlignment",
+ //"getTextDirection",
+ //"getTop",
+ //"getTouchDelegate",
+ //"getTouchables",
+ //"getTranslationX",
+ //"getTranslationY",
+ //"getVerticalFadingEdgeLength",
+ //"getVerticalScrollbarPosition",
+ //"getVerticalScrollbarWidth",
+ //"getViewTreeObserver",
+ //"getVisibility",
+ //"getWidth",
+ //"getWindowId",
+ //"getWindowSystemUiVisbility",
+ //"getWindowToken",
+ //"getWindowVisibility",
+ //"getX",
+ //"getY",
+ //"hasFocus",
+ //"hasFocusable",
+ //"hasOnClickListener",
+ //"hasOverlappingRendering",
+ //"hasTransientState",
+ //"hasWindowFocus",
+ //"isActivated",
+ //"isAttachedToWindow",
+ //"isClickable",
+ //"isDirty",
+ //"isDrawingCacheEnabled",
+ //"isDuplicateParentStateEnabled",
+ //"isEnabled",
+ //"isFocusable",
+ //"isFocusableInTouchWindow",
+ //"isFocused",
+ //"isHapticFeedbackEnabled",
+ //"isHardwareAccelerated",
+ //"isHorizontalFadingEdgeEnabled",
+ //"isHovered",
+ //"idInEditMode",
+ //"isInLayout",
+ //"isInTouchMode",
+ //"isLaidOut",
+ //"isLayoutDirectionResolved",
+ //"isLayoutRequested",
+ //"isLongClickable",
+ //"isOpaque",
+ //"isPaddingRelative",
+ //"isPressed",
+ //"isSaveEnabled",
+ //"isSaveFromParentEnabled",
+ //"isScrollContainer",
+ //"isScrollBarFadingEnabled",
+ //"isSelected",
+ //"isShown",
+ //"isSoundEffectsEnabled",
+ //"isTextAlignmentResolved",
+ //"isTextDirectionResolved",
+ //"isVerticalFadingEdgeEnabled",
+ //"isVerticalScrollBarEnabled"
+ };
+
+ if (isOnParent)
+ query = query + " parent * index:0";
+
+ foreach (var property in properties) {
+ object prop;
+ bool found =
+ MaybeGetProperty<string> (app, query, property, out prop) ||
+ //MaybeGetProperty<int> (app, query, property, out prop) ||
+ MaybeGetProperty<float> (app, query, property, out prop) ||
+ MaybeGetProperty<bool> (app, query, property, out prop);
+
+ //if (found)
+ // Logger.LogLine (string.Format ("{0,-30}: {1}", property, prop));
+ }
+
+ //Logger.LogLine();
+
+ }
+
+ static bool MaybeGetLayerProperty<T> (iOSApp app, string query, string property, out object result)
+ {
+
+ try {
+ result = app.Query (q => q.Raw (query).Invoke ("layer").Invoke (property).Value<T> ()).First ();
+ } catch {
+ result = null;
+ return false;
+ }
+
+ return true;
+ }
+
+ static bool MaybeGetProperty<T> (IApp app, string query, string property, out object result)
+ {
+
+ try {
+ result = app.Query (q => q.Raw (query).Invoke (property).Value<T> ()).First ();
+ } catch {
+ result = null;
+ return false;
+ }
+
+ return true;
+ }
+ }
+}
+
diff --git a/Xamarin.Forms.Core.iOS.UITests/Xamarin.Forms.Core.iOS.UITests.csproj b/Xamarin.Forms.Core.iOS.UITests/Xamarin.Forms.Core.iOS.UITests.csproj
new file mode 100644
index 0000000..2846ddc
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/Xamarin.Forms.Core.iOS.UITests.csproj
@@ -0,0 +1,175 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="12.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+ <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
+ <PropertyGroup>
+ <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+ <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+ <ProjectGuid>{EADD8100-B3AE-4A31-92C4-267A64A1C6EB}</ProjectGuid>
+ <OutputType>Library</OutputType>
+ <AppDesignerFolder>Properties</AppDesignerFolder>
+ <RootNamespace>Xamarin.Forms.Core.UITests</RootNamespace>
+ <AssemblyName>Xamarin.Forms.Core.iOS.UITests</AssemblyName>
+ <TargetFrameworkVersion>v4.5</TargetFrameworkVersion>
+ <FileAlignment>512</FileAlignment>
+ <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\</SolutionDir>
+ <RestorePackages>true</RestorePackages>
+ </PropertyGroup>
+ <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+ <DebugSymbols>true</DebugSymbols>
+ <DebugType>full</DebugType>
+ <Optimize>false</Optimize>
+ <OutputPath>bin\Debug\</OutputPath>
+ <DefineConstants>TRACE;DEBUG;__IOS__;UITEST</DefineConstants>
+ <ErrorReport>prompt</ErrorReport>
+ <WarningLevel>4</WarningLevel>
+ </PropertyGroup>
+ <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+ <DebugType>pdbonly</DebugType>
+ <Optimize>true</Optimize>
+ <OutputPath>bin\Release\</OutputPath>
+ <DefineConstants>TRACE;__IOS__;UITEST</DefineConstants>
+ <ErrorReport>prompt</ErrorReport>
+ <WarningLevel>4</WarningLevel>
+ </PropertyGroup>
+ <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Turkey|AnyCPU'">
+ <DebugSymbols>true</DebugSymbols>
+ <OutputPath>bin\Turkey\</OutputPath>
+ <DefineConstants>TRACE;DEBUG;__IOS__;UITEST</DefineConstants>
+ <DebugType>full</DebugType>
+ <PlatformTarget>AnyCPU</PlatformTarget>
+ <ErrorReport>prompt</ErrorReport>
+ <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet>
+ </PropertyGroup>
+ <ItemGroup>
+ <Reference Include="System" />
+ <Reference Include="System.Core" />
+ <Reference Include="System.Xml.Linq" />
+ <Reference Include="System.Data.DataSetExtensions" />
+ <Reference Include="Microsoft.CSharp" />
+ <Reference Include="System.Data" />
+ <Reference Include="System.Xml" />
+ <Reference Include="nunit.framework">
+ <HintPath>..\packages\NUnit.2.6.4\lib\nunit.framework.dll</HintPath>
+ </Reference>
+ <Reference Include="Xamarin.UITest, Version=1.3.3.0, Culture=neutral, processorArchitecture=MSIL">
+ <HintPath>..\packages\Xamarin.UITest.1.3.3\lib\Xamarin.UITest.dll</HintPath>
+ <Private>True</Private>
+ </Reference>
+ </ItemGroup>
+ <ItemGroup>
+ <Compile Include="BaseTestFixture.cs" />
+ <Compile Include="App.cs" />
+ <Compile Include="PlatformQueries.cs" />
+ <Compile Include="Remotes\BaseViewContainerRemote.cs" />
+ <Compile Include="Remotes\EventViewContainerRemote.cs" />
+ <Compile Include="Remotes\LayeredViewContainerRemote.cs" />
+ <Compile Include="Remotes\ViewContainerRemote.cs" />
+ <Compile Include="Properties\AssemblyInfo.cs" />
+ <Compile Include="Queries.cs" />
+ <Compile Include="Remotes\StateViewContainerRemote.cs" />
+ <Compile Include="Remotes\RemoteFactory.cs" />
+ <Compile Include="Tests\ContextActionsUITests.cs" />
+ <Compile Include="Tests\Legacy-BoundViewUITest.cs" />
+ <Compile Include="Tests\Legacy-ClipToBoundsUITests.cs" />
+ <Compile Include="Tests\Legacy-GroupedListActionsUITests.cs" />
+ <Compile Include="Tests\Legacy-ButtonUITests.cs" />
+ <Compile Include="Tests\Legacy-EditorUITests.cs" />
+ <Compile Include="Tests\Legacy-EntryUITests.cs" />
+ <Compile Include="Tests\Legacy-AbsoluteLayoutGalleryTest.cs" />
+ <Compile Include="Tests\ActivityIndicatorUITests.cs" />
+ <Compile Include="Tests\Legacy-CarouselPageUITests.cs" />
+ <Compile Include="Tests\Legacy-CellsUITests.cs" />
+ <Compile Include="Tests\DatePickerUITests.cs" />
+ <Compile Include="Tests\BoxViewUITests.cs" />
+ <Compile Include="Tests\EditorUITests.cs" />
+ <Compile Include="Tests\FrameUITests.cs" />
+ <Compile Include="Tests\Legacy-GridGalleryUITests.cs" />
+ <Compile Include="Tests\ImageUITests.cs" />
+ <Compile Include="Tests\Legacy-InputIntentUITests.cs" />
+ <Compile Include="Tests\Legacy-ListUITests.cs" />
+ <Compile Include="Tests\Legacy-MapUITests.cs" />
+ <Compile Include="Tests\Legacy-MinimumSizeUITest.cs" />
+ <Compile Include="Tests\Legacy-RelativeLayoutUITest.cs" />
+ <Compile Include="Tests\Legacy-SliderUITests.cs" />
+ <Compile Include="Tests\Legacy-StackLayoutUITest.cs" />
+ <Compile Include="Tests\Legacy-StepperUITests.cs" />
+ <Compile Include="Tests\Legacy-SwitchUITests.cs" />
+ <Compile Include="Tests\Legacy-SearchBarUITests.cs" />
+ <Compile Include="Tests\Legacy-TemplatedCarouselPageUITests.cs" />
+ <Compile Include="Tests\Legacy-TemplatedTabPageUITests.cs" />
+ <Compile Include="Tests\Legacy-TableViewUITests.cs" />
+ <Compile Include="Tests\Legacy-ToolbarGalleryUITests.cs" />
+ <Compile Include="Tests\Legacy-UnevenViewCellUITests.cs" />
+ <Compile Include="Tests\Legacy-ViewCellUITests.cs" />
+ <Compile Include="Tests\Legacy-NavigationBarUITests.cs" />
+ <Compile Include="Tests\WebViewUITests.cs" />
+ <Compile Include="Tests\TimePickerUITests.cs" />
+ <Compile Include="Tests\SwitchUITests.cs" />
+ <Compile Include="Tests\StepperUITests.cs" />
+ <Compile Include="Tests\SliderUITests.cs" />
+ <Compile Include="Tests\SearchBarUITests.cs" />
+ <Compile Include="Tests\ProgressBarUITests.cs" />
+ <Compile Include="Tests\PickerUITests.cs" />
+ <Compile Include="Tests\LabelUITests.cs" />
+ <Compile Include="Tests\EntryUITests.cs" />
+ <Compile Include="Tests\ButtonUITests.cs" />
+ <Compile Include="Tests\ViewUITests.cs" />
+ <Compile Include="Utilities\AppExtensions.cs" />
+ <Compile Include="Utilities\Drag.cs" />
+ <Compile Include="Utilities\Gestures.cs" />
+ <Compile Include="Utilities\Logger.cs" />
+ <Compile Include="Utilities\NumericExtensions.cs" />
+ <Compile Include="Utilities\ParsingUtils.cs" />
+ <Compile Include="Utilities\UITestCustomExceptions.cs" />
+ <Compile Include="Utilities\ViewInspector.cs" />
+ <Compile Include="Tests\DisplayAlertUITests.cs" />
+ <Compile Include="Tests\ActionSheetUITests.cs" />
+ <Compile Include="Tests\ToolbarItemTests.cs" />
+ <Compile Include="Tests\RootGalleryUITests.cs" />
+ <Compile Include="Tests\ScrollViewUITests.cs" />
+ <Compile Include="Tests\Legacy-UnevenListTests.cs" />
+ <Compile Include="Tests\AppearingUITests.cs" />
+ <Compile Include="Tests\AutomationIDUITests.cs" />
+ </ItemGroup>
+ <ItemGroup>
+ <None Include="packages.config" />
+ </ItemGroup>
+ <ItemGroup>
+ <ProjectReference Include="..\Xamarin.Forms.Core\Xamarin.Forms.Core.csproj">
+ <Project>{57B8B73D-C3B5-4C42-869E-7B2F17D354AC}</Project>
+ <Name>Xamarin.Forms.Core</Name>
+ </ProjectReference>
+ <ProjectReference Include="..\Xamarin.Forms.CustomAttributes\Xamarin.Forms.CustomAttributes.csproj">
+ <Project>{4DCD0420-1168-4B77-86DB-6196EE4BD491}</Project>
+ <Name>Xamarin.Forms.CustomAttributes</Name>
+ </ProjectReference>
+ <ProjectReference Include="..\Xamarin.Forms.Maps\Xamarin.Forms.Maps.csproj">
+ <Project>{7d13bac2-c6a4-416a-b07e-c169b199e52b}</Project>
+ <Name>Xamarin.Forms.Maps</Name>
+ </ProjectReference>
+ <ProjectReference Include="..\Xamarin.Forms.Platform\Xamarin.Forms.Platform.csproj">
+ <Project>{67f9d3a8-f71e-4428-913f-c37ae82cdb24}</Project>
+ <Name>Xamarin.Forms.Platform</Name>
+ </ProjectReference>
+ </ItemGroup>
+ <ItemGroup>
+ <Service Include="{82A7F48D-3B50-4B1E-B82E-3ADA8210C358}" />
+ </ItemGroup>
+ <Import Project="..\Xamarin.Forms.Controls.Issues\Xamarin.Forms.Controls.Issues.Shared\Xamarin.Forms.Controls.Issues.Shared.projitems" Label="Shared" />
+ <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+ <Import Project="$(SolutionDir)\.nuget\NuGet.targets" Condition="Exists('$(SolutionDir)\.nuget\NuGet.targets')" />
+ <Target Name="EnsureNuGetPackageBuildImports" BeforeTargets="PrepareForBuild">
+ <PropertyGroup>
+ <ErrorText>This project references NuGet package(s) that are missing on this computer. Enable NuGet Package Restore to download them. For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
+ </PropertyGroup>
+ <Error Condition="!Exists('$(SolutionDir)\.nuget\NuGet.targets')" Text="$([System.String]::Format('$(ErrorText)', '$(SolutionDir)\.nuget\NuGet.targets'))" />
+ </Target>
+ <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
+ Other similar extension points exist, see Microsoft.Common.targets.
+ <Target Name="BeforeBuild">
+ </Target>
+ <Target Name="AfterBuild">
+ </Target>
+ -->
+ <ItemGroup />
+</Project> \ No newline at end of file
diff --git a/Xamarin.Forms.Core.iOS.UITests/packages.config b/Xamarin.Forms.Core.iOS.UITests/packages.config
new file mode 100644
index 0000000..031fa54
--- /dev/null
+++ b/Xamarin.Forms.Core.iOS.UITests/packages.config
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<packages>
+ <package id="NUnit" version="2.6.4" targetFramework="net45" />
+ <package id="Xamarin.UITest" version="1.3.3" targetFramework="net45" />
+</packages> \ No newline at end of file