diff options
Diffstat (limited to 'Xamarin.Forms.UITest.TestCloud')
19 files changed, 2456 insertions, 0 deletions
diff --git a/Xamarin.Forms.UITest.TestCloud/App.config b/Xamarin.Forms.UITest.TestCloud/App.config new file mode 100644 index 00000000..8e156463 --- /dev/null +++ b/Xamarin.Forms.UITest.TestCloud/App.config @@ -0,0 +1,6 @@ +<?xml version="1.0" encoding="utf-8" ?> +<configuration> + <startup> + <supportedRuntime version="v4.0" sku=".NETFramework,Version=v4.5" /> + </startup> +</configuration>
\ No newline at end of file diff --git a/Xamarin.Forms.UITest.TestCloud/DeviceSet.cs b/Xamarin.Forms.UITest.TestCloud/DeviceSet.cs new file mode 100644 index 00000000..3afa0959 --- /dev/null +++ b/Xamarin.Forms.UITest.TestCloud/DeviceSet.cs @@ -0,0 +1,28 @@ +using System.Collections.Generic; + +namespace Xamarin.Forms.UITest.TestCloud +{ + internal class DeviceSet + { + public DeviceSet(List<Platform> deviceSetPlatform, string id, List<string> devices) + { + Id = id; + DeviceSetPlatform = deviceSetPlatform; + Devices = devices; + } + + public string Id { get; private set; } + + public List<Platform> DeviceSetPlatform { get; private set; } + + public List<string> Devices { get; private set; } + + internal enum Platform + { + None, + Android, + IOs, + IOsClassic + } + } +}
\ No newline at end of file diff --git a/Xamarin.Forms.UITest.TestCloud/DeviceSets.cs b/Xamarin.Forms.UITest.TestCloud/DeviceSets.cs new file mode 100644 index 00000000..508253bb --- /dev/null +++ b/Xamarin.Forms.UITest.TestCloud/DeviceSets.cs @@ -0,0 +1,154 @@ +using System.Collections.Generic; + +namespace Xamarin.Forms.UITest.TestCloud +{ + internal static class DeviceSets + { + public static readonly DeviceSet AndroidMassiveSet = + new DeviceSet(new List<DeviceSet.Platform> { DeviceSet.Platform.Android }, "ddaf5646", new List<string> + { + "150+ devices!" + }); + + public static readonly DeviceSet IOsMassiveSet = + new DeviceSet(new List<DeviceSet.Platform> { DeviceSet.Platform.IOs, DeviceSet.Platform.IOsClassic }, "cc20a257", + new List<string> + { + "60+ devices!" + }); + + // Android + public static readonly DeviceSet AndroidFastParallel = + new DeviceSet(new List<DeviceSet.Platform> { DeviceSet.Platform.Android }, "7e376fe0", new List<string> + { + "LG Nexus 5 - Android 4.4.4" + }); + + public static readonly DeviceSet Android5 = new DeviceSet( + new List<DeviceSet.Platform> { DeviceSet.Platform.Android }, "f2d90195", new List<string> + { + "LG Nexus 5- Android 5.1.1" + }); + + public static readonly DeviceSet Android6 = new DeviceSet( + new List<DeviceSet.Platform> { DeviceSet.Platform.Android }, "012c8f06", new List<string> + { + "LG Nexus 5 - Android 6.0.1" + }); + + public static readonly DeviceSet SethLocalDeviceSetAndroid = + new DeviceSet(new List<DeviceSet.Platform> { DeviceSet.Platform.Android }, "9e76018b", new List<string> + { + "Google Nexus 7 - 4.4.2", + "Samsung Galaxy S4 (Google Play Edition GT-I9505G) - Seth -> 4.4, Test Cloud -> 4.4.2 (closest match)" + }); + + public static readonly DeviceSet IcsSmallSet = + new DeviceSet(new List<DeviceSet.Platform> { DeviceSet.Platform.Android }, "fc61dbe3", new List<string> + { + "Amazon Kindle Fire (2nd Gen) - 4.0.3", + "HTC Desire - 4.0.3", + "Samsung Galaxy Tab 2 - 4.0.4", + "Sony Xperia neo L - 4.0.3" + }); + + public static readonly DeviceSet AndroidAllApiSmallSet = + new DeviceSet(new List<DeviceSet.Platform> { DeviceSet.Platform.Android }, "4f912d99", new List<string> + { + "HTC Sensation XL - 4.0.3", + "Amazon Kindle Fire (2nd Generation) - 4.0.3", + "Samsung Galaxy Tab 2 - 4.0.4", + "Motorola ATRIX 2 - 4.0.4", + "Samsung Galaxy Note II - 4.1.1", + "HP Slate 7 - 4.1.1", + "Sony Xperia Z - 4.1.2", + "Samsung Galaxy Tab 3 7.0 - 4.1.2", + "Google Nexus 7 - 4.2", + "Oppo R819 - 4.2.1", + "Samsung Galaxy S4 Zoom - 4.2.2", + "Acer Iconia Tab A1 - 4.2.2", + "Samsung Galaxy S4 (Octo-core) - 4.3", + "Oppo N1 - 4.3", + "LG Nexus 5 - 4.4", + "Samsung Google Nexus 10 - 4.4", + "Samsung Galaxy S5 - 4.4.2", + "Samsung Galaxy Note - 3 (Octo-Core) - 4.4.2" + }); + + public static readonly DeviceSet IOsFastParallel = + new DeviceSet(new List<DeviceSet.Platform> { DeviceSet.Platform.IOs, DeviceSet.Platform.IOsClassic }, "7f2fa3ae", + new List<string> + { + "Apple iPad Mini Retina - iOS 7.1.2" + }); + + // iOS + public static readonly DeviceSet SethLocalDeviceSetiOs = + new DeviceSet(new List<DeviceSet.Platform> { DeviceSet.Platform.IOs, DeviceSet.Platform.IOsClassic }, "b417f165", + new List<string> + { + "Apple iPhone 5 - iOS 7.1.1", + "Apple iPad Air - iOS 7.1.1" + }); + + public static readonly DeviceSet IOsAllApiSmallSet = + new DeviceSet(new List<DeviceSet.Platform> { DeviceSet.Platform.IOs, DeviceSet.Platform.IOsClassic }, "d2d6440e", + new List<string> + { + "Apple iPod Touch 5th Gen - iOS 6.0.1", + "Apple iPad 2 - iOS 6.1.3", + "Apple iPhone 4 - iOS 6.1.3", + "Apple iPhone 5 - iOS 6.1.4", + "Apple iPhone 3GS - iOS 6.1.6", + "Apple iPod Touch 4th Gen - iOS 6.1.6", + "Apple iPhone 5C - iOS 7.0.2", + "Apple iPad Mini - iOS 7.0.3", + "Apple iPad 4 - iOS 7.0.4", + "Apple iPhone 5S - iOS 7.0.4", + "Apple iPad Air - iOS 7.1", + "Apple iPhone 5C - iOS 7.1", + "Apple iPad Air - iOS 7.1.1", + "Apple iPhone 4S - iOS 7.1.1", + "Apple iPhone 5 - iOS 7.1.1" + }); + + public static readonly DeviceSet IOs8 = + new DeviceSet(new List<DeviceSet.Platform> { DeviceSet.Platform.IOs, DeviceSet.Platform.IOsClassic }, "56293ce6", + new List<string> + { + "Apple iPhone 5S - iOS 8.1" + }); + + public static readonly DeviceSet IOs7AndiOs8 = + new DeviceSet(new List<DeviceSet.Platform> { DeviceSet.Platform.IOs, DeviceSet.Platform.IOsClassic }, "5190fc68", + new List<string> + { + "Apple Ipad Retina Mini - iOS 7.1.2", + "Apple Iphone 6 Plus - 8.1.3" + }); + + public static readonly DeviceSet IOs6PhoneTablet = + new DeviceSet(new List<DeviceSet.Platform> { DeviceSet.Platform.IOs, DeviceSet.Platform.IOsClassic }, "212c4682", + new List<string> + { + "Apple Ipad 4 - iOS 6.1.3", + "Apple Iphone 4 - iOS 6.1.3" + }); + + public static readonly DeviceSet IOs9 = + new DeviceSet(new List<DeviceSet.Platform> { DeviceSet.Platform.IOs, DeviceSet.Platform.IOsClassic }, "dc3140fd", + new List<string> + { + "Apple Iphone 6 - iOS 9.0", + "Apple Ipad Air - iOS 9.0" + }); + + public static readonly DeviceSet IOs91 = + new DeviceSet(new List<DeviceSet.Platform> { DeviceSet.Platform.IOs, DeviceSet.Platform.IOsClassic }, "7f4b13f8", + new List<string> + { + "Apple Iphone 6S - iOS 9.1", + "Apple Ipad Air 2 - iOS 9.1" + }); + } +}
\ No newline at end of file diff --git a/Xamarin.Forms.UITest.TestCloud/LoaderActions.cs b/Xamarin.Forms.UITest.TestCloud/LoaderActions.cs new file mode 100644 index 00000000..93edee2b --- /dev/null +++ b/Xamarin.Forms.UITest.TestCloud/LoaderActions.cs @@ -0,0 +1,41 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using Xamarin.Forms.Loader; + +namespace Xamarin.Forms.UITest.TestCloud +{ + internal class LoaderActions + { + readonly IEnumerable<string> _testCategories; + + public LoaderActions() + { + var formsLoader = new FormsLoader(); + + var categoriesOnTypes = + from type in formsLoader.IOSTestTypes() + from categoryAttribute in type.Categories() + select categoryAttribute.Name; + + var categoriesOnMembers = + from type in formsLoader.IOSTestTypes() + from members in type.Members() + from categoryAttribute in members.CategoryAttributes() + select categoryAttribute.Name; + + _testCategories = categoriesOnTypes.Union(categoriesOnMembers); + } + + public void ListCategories() + { + foreach (string category in _testCategories) + Console.WriteLine(category); + } + + public bool ValidateCategory(string category) + { + return _testCategories.Any(k => k == category) || category == "All"; + } + } +}
\ No newline at end of file diff --git a/Xamarin.Forms.UITest.TestCloud/Mono.Options/ArgumentSource.cs b/Xamarin.Forms.UITest.TestCloud/Mono.Options/ArgumentSource.cs new file mode 100644 index 00000000..da24d02b --- /dev/null +++ b/Xamarin.Forms.UITest.TestCloud/Mono.Options/ArgumentSource.cs @@ -0,0 +1,78 @@ +using System.Collections.Generic; +using System.IO; +using System.Text; + +namespace Mono.Options +{ + public abstract class ArgumentSource + { + public abstract string Description { get; } + + public abstract string[] GetNames(); + public abstract bool GetArguments(string value, out IEnumerable<string> replacement); + + public static IEnumerable<string> GetArgumentsFromFile(string file) + { + return GetArguments(File.OpenText(file), true); + } + + public static IEnumerable<string> GetArguments(TextReader reader) + { + return GetArguments(reader, false); + } + + // Cribbed from mcs/driver.cs:LoadArgs(string) + static IEnumerable<string> GetArguments(TextReader reader, bool close) + { + try + { + StringBuilder arg = new StringBuilder(); + + string line; + while ((line = reader.ReadLine()) != null) + { + int t = line.Length; + + for (int i = 0; i < t; i++) + { + char c = line[i]; + + if (c == '"' || c == '\'') + { + char end = c; + + for (i++; i < t; i++) + { + c = line[i]; + + if (c == end) + break; + arg.Append(c); + } + } + else if (c == ' ') + { + if (arg.Length > 0) + { + yield return arg.ToString(); + arg.Length = 0; + } + } + else + arg.Append(c); + } + if (arg.Length > 0) + { + yield return arg.ToString(); + arg.Length = 0; + } + } + } + finally + { + if (close) + reader.Close(); + } + } + } +}
\ No newline at end of file diff --git a/Xamarin.Forms.UITest.TestCloud/Mono.Options/Option.cs b/Xamarin.Forms.UITest.TestCloud/Mono.Options/Option.cs new file mode 100644 index 00000000..f91934c2 --- /dev/null +++ b/Xamarin.Forms.UITest.TestCloud/Mono.Options/Option.cs @@ -0,0 +1,221 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel; + +namespace Mono.Options +{ + public abstract class Option + { + static readonly char[] NameTerminator = { '=', ':' }; + + protected Option(string prototype, string description) + : this(prototype, description, 1, false) + { + } + + protected Option(string prototype, string description, int maxValueCount) + : this(prototype, description, maxValueCount, false) + { + } + + protected Option(string prototype, string description, int maxValueCount, bool hidden) + { + if (prototype == null) + throw new ArgumentNullException("prototype"); + if (prototype.Length == 0) + throw new ArgumentException("Cannot be the empty string.", "prototype"); + if (maxValueCount < 0) + throw new ArgumentOutOfRangeException("maxValueCount"); + + Prototype = prototype; + Description = description; + MaxValueCount = maxValueCount; + Names = (this is OptionSet.Category) + // append GetHashCode() so that "duplicate" categories have distinct + // names, e.g. adding multiple "" categories should be valid. + ? new[] { prototype + GetHashCode() } + : prototype.Split('|'); + + if (this is OptionSet.Category) + return; + + OptionValueType = ParsePrototype(); + Hidden = hidden; + + if (MaxValueCount == 0 && OptionValueType != OptionValueType.None) + { + throw new ArgumentException( + "Cannot provide maxValueCount of 0 for OptionValueType.Required or " + + "OptionValueType.Optional.", + "maxValueCount"); + } + if (OptionValueType == OptionValueType.None && maxValueCount > 1) + { + throw new ArgumentException( + string.Format("Cannot provide maxValueCount of {0} for OptionValueType.None.", maxValueCount), + "maxValueCount"); + } + if (Array.IndexOf(Names, "<>") >= 0 && + ((Names.Length == 1 && OptionValueType != OptionValueType.None) || + (Names.Length > 1 && MaxValueCount > 1))) + { + throw new ArgumentException( + "The default option handler '<>' cannot require values.", + "prototype"); + } + } + + public string Prototype { get; } + + public string Description { get; } + + public OptionValueType OptionValueType { get; } + + public int MaxValueCount { get; } + + public bool Hidden { get; } + + internal string[] Names { get; } + + internal string[] ValueSeparators { get; private set; } + + public string[] GetNames() + { + return (string[])Names.Clone(); + } + + public string[] GetValueSeparators() + { + if (ValueSeparators == null) + return new string[0]; + return (string[])ValueSeparators.Clone(); + } + + protected static T Parse<T>(string value, OptionContext c) + { + Type tt = typeof (T); + bool nullable = tt.IsValueType && tt.IsGenericType && + !tt.IsGenericTypeDefinition && + tt.GetGenericTypeDefinition() == typeof (Nullable<>); + Type targetType = nullable ? tt.GetGenericArguments()[0] : typeof (T); + TypeConverter conv = TypeDescriptor.GetConverter(targetType); + T t = default(T); + try + { + if (value != null) + t = (T)conv.ConvertFromString(value); + } + catch (Exception e) + { + throw new OptionException( + string.Format( + c.OptionSet.MessageLocalizer("Could not convert string `{0}' to type {1} for option `{2}'."), + value, targetType.Name, c.OptionName), + c.OptionName, e); + } + return t; + } + + OptionValueType ParsePrototype() + { + char type = '\0'; + List<string> seps = new List<string>(); + for (int i = 0; i < Names.Length; ++i) + { + string name = Names[i]; + if (name.Length == 0) + throw new ArgumentException("Empty option names are not supported.", "prototype"); + + int end = name.IndexOfAny(NameTerminator); + if (end == -1) + continue; + Names[i] = name.Substring(0, end); + if (type == '\0' || type == name[end]) + type = name[end]; + else + { + throw new ArgumentException( + string.Format("Conflicting option types: '{0}' vs. '{1}'.", type, name[end]), + "prototype"); + } + AddSeparators(name, end, seps); + } + + if (type == '\0') + return OptionValueType.None; + + if (MaxValueCount <= 1 && seps.Count != 0) + { + throw new ArgumentException( + string.Format("Cannot provide key/value separators for Options taking {0} value(s).", MaxValueCount), + "prototype"); + } + if (MaxValueCount > 1) + { + if (seps.Count == 0) + ValueSeparators = new[] { ":", "=" }; + else if (seps.Count == 1 && seps[0].Length == 0) + ValueSeparators = null; + else + ValueSeparators = seps.ToArray(); + } + + return type == '=' ? OptionValueType.Required : OptionValueType.Optional; + } + + static void AddSeparators(string name, int end, ICollection<string> seps) + { + int start = -1; + for (int i = end + 1; i < name.Length; ++i) + { + switch (name[i]) + { + case '{': + if (start != -1) + { + throw new ArgumentException( + string.Format("Ill-formed name/value separator found in \"{0}\".", name), + "prototype"); + } + start = i + 1; + break; + case '}': + if (start == -1) + { + throw new ArgumentException( + string.Format("Ill-formed name/value separator found in \"{0}\".", name), + "prototype"); + } + seps.Add(name.Substring(start, i - start)); + start = -1; + break; + default: + if (start == -1) + seps.Add(name[i].ToString()); + break; + } + } + if (start != -1) + { + throw new ArgumentException( + string.Format("Ill-formed name/value separator found in \"{0}\".", name), + "prototype"); + } + } + + public void Invoke(OptionContext c) + { + OnParseComplete(c); + c.OptionName = null; + c.Option = null; + c.OptionValues.Clear(); + } + + protected abstract void OnParseComplete(OptionContext c); + + public override string ToString() + { + return Prototype; + } + } +}
\ No newline at end of file diff --git a/Xamarin.Forms.UITest.TestCloud/Mono.Options/OptionAction.cs b/Xamarin.Forms.UITest.TestCloud/Mono.Options/OptionAction.cs new file mode 100644 index 00000000..2c8fd7b3 --- /dev/null +++ b/Xamarin.Forms.UITest.TestCloud/Mono.Options/OptionAction.cs @@ -0,0 +1,4 @@ +namespace Mono.Options +{ + public delegate void OptionAction<TKey, TValue>(TKey key, TValue value); +}
\ No newline at end of file diff --git a/Xamarin.Forms.UITest.TestCloud/Mono.Options/OptionContext.cs b/Xamarin.Forms.UITest.TestCloud/Mono.Options/OptionContext.cs new file mode 100644 index 00000000..4a718360 --- /dev/null +++ b/Xamarin.Forms.UITest.TestCloud/Mono.Options/OptionContext.cs @@ -0,0 +1,21 @@ +namespace Mono.Options +{ + public class OptionContext + { + public OptionContext(OptionSet set) + { + OptionSet = set; + OptionValues = new OptionValueCollection(this); + } + + public Option Option { get; set; } + + public string OptionName { get; set; } + + public int OptionIndex { get; set; } + + public OptionSet OptionSet { get; } + + public OptionValueCollection OptionValues { get; } + } +}
\ No newline at end of file diff --git a/Xamarin.Forms.UITest.TestCloud/Mono.Options/OptionException.cs b/Xamarin.Forms.UITest.TestCloud/Mono.Options/OptionException.cs new file mode 100644 index 00000000..8a8229e7 --- /dev/null +++ b/Xamarin.Forms.UITest.TestCloud/Mono.Options/OptionException.cs @@ -0,0 +1,41 @@ +using System; +using System.Runtime.Serialization; +using System.Security.Permissions; + +namespace Mono.Options +{ + [Serializable] + public class OptionException : Exception + { + public OptionException() + { + } + + public OptionException(string message, string optionName) + : base(message) + { + OptionName = optionName; + } + + public OptionException(string message, string optionName, Exception innerException) + : base(message, innerException) + { + OptionName = optionName; + } + + protected OptionException(SerializationInfo info, StreamingContext context) + : base(info, context) + { + OptionName = info.GetString("OptionName"); + } + + public string OptionName { get; } + + [SecurityPermission(SecurityAction.LinkDemand, SerializationFormatter = true)] + public override void GetObjectData(SerializationInfo info, StreamingContext context) + { + base.GetObjectData(info, context); + info.AddValue("OptionName", OptionName); + } + } +}
\ No newline at end of file diff --git a/Xamarin.Forms.UITest.TestCloud/Mono.Options/OptionSet.cs b/Xamarin.Forms.UITest.TestCloud/Mono.Options/OptionSet.cs new file mode 100644 index 00000000..5d406705 --- /dev/null +++ b/Xamarin.Forms.UITest.TestCloud/Mono.Options/OptionSet.cs @@ -0,0 +1,718 @@ +using System; +using System.Collections; +using System.Collections.Generic; +using System.Collections.ObjectModel; +using System.IO; +using System.Text; +using System.Text.RegularExpressions; + +namespace Mono.Options +{ + public class OptionSet : KeyedCollection<string, Option> + { + const int OptionWidth = 29; + const int DescriptionFirstWidth = 80 - OptionWidth; + const int DescriptionRemWidth = 80 - OptionWidth - 2; + + readonly Regex _valueOption = new Regex( + @"^(?<flag>--|-|/)(?<name>[^:=]+)((?<sep>[:=])(?<value>.*))?$"); + + readonly List<ArgumentSource> _sources = new List<ArgumentSource>(); + + public OptionSet() + : this(delegate(string f) { return f; }) + { + } + + public OptionSet(Converter<string, string> localizer) + { + MessageLocalizer = localizer; + ArgumentSources = new ReadOnlyCollection<ArgumentSource>(_sources); + } + + public Converter<string, string> MessageLocalizer { get; } + + public ReadOnlyCollection<ArgumentSource> ArgumentSources { get; } + + protected override string GetKeyForItem(Option item) + { + if (item == null) + throw new ArgumentNullException("option"); + if (item.Names != null && item.Names.Length > 0) + return item.Names[0]; + // This should never happen, as it's invalid for Option to be + // constructed w/o any names. + throw new InvalidOperationException("Option has no names!"); + } + + [Obsolete("Use KeyedCollection.this[string]")] + protected Option GetOptionForName(string option) + { + if (option == null) + throw new ArgumentNullException("option"); + try + { + return base[option]; + } + catch (KeyNotFoundException) + { + return null; + } + } + + protected override void InsertItem(int index, Option item) + { + base.InsertItem(index, item); + AddImpl(item); + } + + protected override void RemoveItem(int index) + { + Option p = Items[index]; + base.RemoveItem(index); + // KeyedCollection.RemoveItem() handles the 0th item + for (int i = 1; i < p.Names.Length; ++i) + Dictionary.Remove(p.Names[i]); + } + + protected override void SetItem(int index, Option item) + { + base.SetItem(index, item); + AddImpl(item); + } + + void AddImpl(Option option) + { + if (option == null) + throw new ArgumentNullException("option"); + List<string> added = new List<string>(option.Names.Length); + try + { + // KeyedCollection.InsertItem/SetItem handle the 0th name. + for (int i = 1; i < option.Names.Length; ++i) + { + Dictionary.Add(option.Names[i], option); + added.Add(option.Names[i]); + } + } + catch (Exception) + { + foreach (string name in added) + Dictionary.Remove(name); + throw; + } + } + + public OptionSet Add(string header) + { + if (header == null) + throw new ArgumentNullException("header"); + Add(new Category(header)); + return this; + } + + public new OptionSet Add(Option option) + { + base.Add(option); + return this; + } + + public OptionSet Add(string prototype, Action<string> action) + { + return Add(prototype, null, action); + } + + public OptionSet Add(string prototype, string description, Action<string> action) + { + return Add(prototype, description, action, false); + } + + public OptionSet Add(string prototype, string description, Action<string> action, bool hidden) + { + if (action == null) + throw new ArgumentNullException("action"); + Option p = new ActionOption(prototype, description, 1, + delegate(OptionValueCollection v) { action(v[0]); }, hidden); + base.Add(p); + return this; + } + + public OptionSet Add(string prototype, OptionAction<string, string> action) + { + return Add(prototype, null, action); + } + + public OptionSet Add(string prototype, string description, OptionAction<string, string> action) + { + return Add(prototype, description, action, false); + } + + public OptionSet Add(string prototype, string description, OptionAction<string, string> action, bool hidden) + { + if (action == null) + throw new ArgumentNullException("action"); + Option p = new ActionOption(prototype, description, 2, + delegate(OptionValueCollection v) { action(v[0], v[1]); }, hidden); + base.Add(p); + return this; + } + + public OptionSet Add<T>(string prototype, Action<T> action) + { + return Add(prototype, null, action); + } + + public OptionSet Add<T>(string prototype, string description, Action<T> action) + { + return Add(new ActionOption<T>(prototype, description, action)); + } + + public OptionSet Add<TKey, TValue>(string prototype, OptionAction<TKey, TValue> action) + { + return Add(prototype, null, action); + } + + public OptionSet Add<TKey, TValue>(string prototype, string description, OptionAction<TKey, TValue> action) + { + return Add(new ActionOption<TKey, TValue>(prototype, description, action)); + } + + public OptionSet Add(ArgumentSource source) + { + if (source == null) + throw new ArgumentNullException("source"); + _sources.Add(source); + return this; + } + + protected virtual OptionContext CreateOptionContext() + { + return new OptionContext(this); + } + + public List<string> Parse(IEnumerable<string> arguments) + { + if (arguments == null) + throw new ArgumentNullException("arguments"); + OptionContext c = CreateOptionContext(); + c.OptionIndex = -1; + bool process = true; + List<string> unprocessed = new List<string>(); + Option def = Contains("<>") ? this["<>"] : null; + ArgumentEnumerator ae = new ArgumentEnumerator(arguments); + foreach (string argument in ae) + { + ++c.OptionIndex; + if (argument == "--") + { + process = false; + continue; + } + if (!process) + { + Unprocessed(unprocessed, def, c, argument); + continue; + } + if (AddSource(ae, argument)) + continue; + if (!Parse(argument, c)) + Unprocessed(unprocessed, def, c, argument); + } + if (c.Option != null) + c.Option.Invoke(c); + return unprocessed; + } + + bool AddSource(ArgumentEnumerator ae, string argument) + { + foreach (ArgumentSource source in _sources) + { + IEnumerable<string> replacement; + if (!source.GetArguments(argument, out replacement)) + continue; + ae.Add(replacement); + return true; + } + return false; + } + + static bool Unprocessed(ICollection<string> extra, Option def, OptionContext c, string argument) + { + if (def == null) + { + extra.Add(argument); + return false; + } + c.OptionValues.Add(argument); + c.Option = def; + c.Option.Invoke(c); + return false; + } + + protected bool GetOptionParts(string argument, out string flag, out string name, out string sep, out string value) + { + if (argument == null) + throw new ArgumentNullException("argument"); + + flag = name = sep = value = null; + Match m = _valueOption.Match(argument); + if (!m.Success) + return false; + flag = m.Groups["flag"].Value; + name = m.Groups["name"].Value; + if (m.Groups["sep"].Success && m.Groups["value"].Success) + { + sep = m.Groups["sep"].Value; + value = m.Groups["value"].Value; + } + return true; + } + + protected virtual bool Parse(string argument, OptionContext c) + { + if (c.Option != null) + { + ParseValue(argument, c); + return true; + } + + string f, n, s, v; + if (!GetOptionParts(argument, out f, out n, out s, out v)) + return false; + + Option p; + if (Contains(n)) + { + p = this[n]; + c.OptionName = f + n; + c.Option = p; + switch (p.OptionValueType) + { + case OptionValueType.None: + c.OptionValues.Add(n); + c.Option.Invoke(c); + break; + case OptionValueType.Optional: + case OptionValueType.Required: + ParseValue(v, c); + break; + } + return true; + } + // no match; is it a bool option? + if (ParseBool(argument, n, c)) + return true; + // is it a bundled option? + if (ParseBundledValue(f, string.Concat(n + s + v), c)) + return true; + + return false; + } + + void ParseValue(string option, OptionContext c) + { + if (option != null) + { + foreach (string o in c.Option.ValueSeparators != null + ? option.Split(c.Option.ValueSeparators, c.Option.MaxValueCount - c.OptionValues.Count, StringSplitOptions.None) + : new[] { option }) + c.OptionValues.Add(o); + } + if (c.OptionValues.Count == c.Option.MaxValueCount || + c.Option.OptionValueType == OptionValueType.Optional) + c.Option.Invoke(c); + else if (c.OptionValues.Count > c.Option.MaxValueCount) + { + throw new OptionException(MessageLocalizer(string.Format( + "Error: Found {0} option values when expecting {1}.", + c.OptionValues.Count, c.Option.MaxValueCount)), + c.OptionName); + } + } + + bool ParseBool(string option, string n, OptionContext c) + { + Option p; + string rn; + if (n.Length >= 1 && (n[n.Length - 1] == '+' || n[n.Length - 1] == '-') && + Contains((rn = n.Substring(0, n.Length - 1)))) + { + p = this[rn]; + string v = n[n.Length - 1] == '+' ? option : null; + c.OptionName = option; + c.Option = p; + c.OptionValues.Add(v); + p.Invoke(c); + return true; + } + return false; + } + + bool ParseBundledValue(string f, string n, OptionContext c) + { + if (f != "-") + return false; + for (int i = 0; i < n.Length; ++i) + { + Option p; + string opt = f + n[i]; + string rn = n[i].ToString(); + if (!Contains(rn)) + { + if (i == 0) + return false; + throw new OptionException(string.Format(MessageLocalizer( + "Cannot bundle unregistered option '{0}'."), opt), opt); + } + p = this[rn]; + switch (p.OptionValueType) + { + case OptionValueType.None: + Invoke(c, opt, n, p); + break; + case OptionValueType.Optional: + case OptionValueType.Required: + { + string v = n.Substring(i + 1); + c.Option = p; + c.OptionName = opt; + ParseValue(v.Length != 0 ? v : null, c); + return true; + } + default: + throw new InvalidOperationException("Unknown OptionValueType: " + p.OptionValueType); + } + } + return true; + } + + static void Invoke(OptionContext c, string name, string value, Option option) + { + c.OptionName = name; + c.Option = option; + c.OptionValues.Add(value); + option.Invoke(c); + } + + public void WriteOptionDescriptions(TextWriter o) + { + foreach (Option p in this) + { + int written = 0; + + if (p.Hidden) + continue; + + Category c = p as Category; + if (c != null) + { + WriteDescription(o, p.Description, "", 80, 80); + continue; + } + + if (!WriteOptionPrototype(o, p, ref written)) + continue; + + if (written < OptionWidth) + o.Write(new string(' ', OptionWidth - written)); + else + { + o.WriteLine(); + o.Write(new string(' ', OptionWidth)); + } + + WriteDescription(o, p.Description, new string(' ', OptionWidth + 2), + DescriptionFirstWidth, DescriptionRemWidth); + } + + foreach (ArgumentSource s in _sources) + { + string[] names = s.GetNames(); + if (names == null || names.Length == 0) + continue; + + int written = 0; + + Write(o, ref written, " "); + Write(o, ref written, names[0]); + for (int i = 1; i < names.Length; ++i) + { + Write(o, ref written, ", "); + Write(o, ref written, names[i]); + } + + if (written < OptionWidth) + o.Write(new string(' ', OptionWidth - written)); + else + { + o.WriteLine(); + o.Write(new string(' ', OptionWidth)); + } + + WriteDescription(o, s.Description, new string(' ', OptionWidth + 2), + DescriptionFirstWidth, DescriptionRemWidth); + } + } + + void WriteDescription(TextWriter o, string value, string prefix, int firstWidth, int remWidth) + { + bool indent = false; + foreach (string line in GetLines(MessageLocalizer(GetDescription(value)), firstWidth, remWidth)) + { + if (indent) + o.Write(prefix); + o.WriteLine(line); + indent = true; + } + } + + bool WriteOptionPrototype(TextWriter o, Option p, ref int written) + { + string[] names = p.Names; + + int i = GetNextOptionIndex(names, 0); + if (i == names.Length) + return false; + + if (names[i].Length == 1) + { + Write(o, ref written, " -"); + Write(o, ref written, names[0]); + } + else + { + Write(o, ref written, " --"); + Write(o, ref written, names[0]); + } + + for (i = GetNextOptionIndex(names, i + 1); + i < names.Length; + i = GetNextOptionIndex(names, i + 1)) + { + Write(o, ref written, ", "); + Write(o, ref written, names[i].Length == 1 ? "-" : "--"); + Write(o, ref written, names[i]); + } + + if (p.OptionValueType == OptionValueType.Optional || + p.OptionValueType == OptionValueType.Required) + { + if (p.OptionValueType == OptionValueType.Optional) + Write(o, ref written, MessageLocalizer("[")); + Write(o, ref written, MessageLocalizer("=" + GetArgumentName(0, p.MaxValueCount, p.Description))); + string sep = p.ValueSeparators != null && p.ValueSeparators.Length > 0 + ? p.ValueSeparators[0] + : " "; + for (int c = 1; c < p.MaxValueCount; ++c) + Write(o, ref written, MessageLocalizer(sep + GetArgumentName(c, p.MaxValueCount, p.Description))); + if (p.OptionValueType == OptionValueType.Optional) + Write(o, ref written, MessageLocalizer("]")); + } + return true; + } + + static int GetNextOptionIndex(string[] names, int i) + { + while (i < names.Length && names[i] == "<>") + ++i; + return i; + } + + static void Write(TextWriter o, ref int n, string s) + { + n += s.Length; + o.Write(s); + } + + static string GetArgumentName(int index, int maxIndex, string description) + { + if (description == null) + return maxIndex == 1 ? "VALUE" : "VALUE" + (index + 1); + string[] nameStart; + if (maxIndex == 1) + nameStart = new[] { "{0:", "{" }; + else + nameStart = new[] { "{" + index + ":" }; + for (int i = 0; i < nameStart.Length; ++i) + { + int start, j = 0; + do + { + start = description.IndexOf(nameStart[i], j); + } while (start >= 0 && j != 0 ? description[j++ - 1] == '{' : false); + if (start == -1) + continue; + int end = description.IndexOf("}", start); + if (end == -1) + continue; + return description.Substring(start + nameStart[i].Length, end - start - nameStart[i].Length); + } + return maxIndex == 1 ? "VALUE" : "VALUE" + (index + 1); + } + + static string GetDescription(string description) + { + if (description == null) + return string.Empty; + StringBuilder sb = new StringBuilder(description.Length); + int start = -1; + for (int i = 0; i < description.Length; ++i) + { + switch (description[i]) + { + case '{': + if (i == start) + { + sb.Append('{'); + start = -1; + } + else if (start < 0) + start = i + 1; + break; + case '}': + if (start < 0) + { + if ((i + 1) == description.Length || description[i + 1] != '}') + throw new InvalidOperationException("Invalid option description: " + description); + ++i; + sb.Append("}"); + } + else + { + sb.Append(description.Substring(start, i - start)); + start = -1; + } + break; + case ':': + if (start < 0) + goto default; + start = i + 1; + break; + default: + if (start < 0) + sb.Append(description[i]); + break; + } + } + return sb.ToString(); + } + + static IEnumerable<string> GetLines(string description, int firstWidth, int remWidth) + { + return StringCoda.WrappedLines(description, firstWidth, remWidth); + } + + internal sealed class Category : Option + { + // Prototype starts with '=' because this is an invalid prototype + // (see Option.ParsePrototype(), and thus it'll prevent Category + // instances from being accidentally used as normal options. + public Category(string description) + : base("=:Category:= " + description, description) + { + } + + protected override void OnParseComplete(OptionContext c) + { + throw new NotSupportedException("Category.OnParseComplete should not be invoked."); + } + } + + sealed class ActionOption : Option + { + readonly Action<OptionValueCollection> _action; + + public ActionOption(string prototype, string description, int count, Action<OptionValueCollection> action) + : this(prototype, description, count, action, false) + { + } + + public ActionOption(string prototype, string description, int count, Action<OptionValueCollection> action, + bool hidden) + : base(prototype, description, count, hidden) + { + if (action == null) + throw new ArgumentNullException("action"); + _action = action; + } + + protected override void OnParseComplete(OptionContext c) + { + _action(c.OptionValues); + } + } + + sealed class ActionOption<T> : Option + { + readonly Action<T> _action; + + public ActionOption(string prototype, string description, Action<T> action) + : base(prototype, description, 1) + { + if (action == null) + throw new ArgumentNullException("action"); + _action = action; + } + + protected override void OnParseComplete(OptionContext c) + { + _action(Parse<T>(c.OptionValues[0], c)); + } + } + + sealed class ActionOption<TKey, TValue> : Option + { + readonly OptionAction<TKey, TValue> _action; + + public ActionOption(string prototype, string description, OptionAction<TKey, TValue> action) + : base(prototype, description, 2) + { + if (action == null) + throw new ArgumentNullException("action"); + _action = action; + } + + protected override void OnParseComplete(OptionContext c) + { + _action( + Parse<TKey>(c.OptionValues[0], c), + Parse<TValue>(c.OptionValues[1], c)); + } + } + + class ArgumentEnumerator : IEnumerable<string> + { + readonly List<IEnumerator<string>> _sources = new List<IEnumerator<string>>(); + + public ArgumentEnumerator(IEnumerable<string> arguments) + { + _sources.Add(arguments.GetEnumerator()); + } + + public IEnumerator<string> GetEnumerator() + { + do + { + IEnumerator<string> c = _sources[_sources.Count - 1]; + if (c.MoveNext()) + yield return c.Current; + else + { + c.Dispose(); + _sources.RemoveAt(_sources.Count - 1); + } + } while (_sources.Count > 0); + } + + IEnumerator IEnumerable.GetEnumerator() + { + return GetEnumerator(); + } + + public void Add(IEnumerable<string> arguments) + { + _sources.Add(arguments.GetEnumerator()); + } + } + } +}
\ No newline at end of file diff --git a/Xamarin.Forms.UITest.TestCloud/Mono.Options/OptionValueCollection.cs b/Xamarin.Forms.UITest.TestCloud/Mono.Options/OptionValueCollection.cs new file mode 100644 index 00000000..6ed60483 --- /dev/null +++ b/Xamarin.Forms.UITest.TestCloud/Mono.Options/OptionValueCollection.cs @@ -0,0 +1,182 @@ +using System; +using System.Collections; +using System.Collections.Generic; + +namespace Mono.Options +{ + public class OptionValueCollection : IList, IList<string> + { + readonly OptionContext _c; + readonly List<string> _values = new List<string>(); + + internal OptionValueCollection(OptionContext c) + { + _c = c; + } + + #region IEnumerable + + IEnumerator IEnumerable.GetEnumerator() + { + return _values.GetEnumerator(); + } + + #endregion + + #region IEnumerable<T> + + public IEnumerator<string> GetEnumerator() + { + return _values.GetEnumerator(); + } + + #endregion + + public List<string> ToList() + { + return new List<string>(_values); + } + + public string[] ToArray() + { + return _values.ToArray(); + } + + public override string ToString() + { + return string.Join(", ", _values.ToArray()); + } + + #region ICollection + + void ICollection.CopyTo(Array array, int index) + { + (_values as ICollection).CopyTo(array, index); + } + + bool ICollection.IsSynchronized => (_values as ICollection).IsSynchronized; + + object ICollection.SyncRoot => (_values as ICollection).SyncRoot; + + #endregion + + #region ICollection<T> + + public void Add(string item) + { + _values.Add(item); + } + + public void Clear() + { + _values.Clear(); + } + + public bool Contains(string item) + { + return _values.Contains(item); + } + + public void CopyTo(string[] array, int arrayIndex) + { + _values.CopyTo(array, arrayIndex); + } + + public bool Remove(string item) + { + return _values.Remove(item); + } + + public int Count => _values.Count; + + public bool IsReadOnly => false; + + #endregion + + #region IList + + int IList.Add(object value) + { + return (_values as IList).Add(value); + } + + bool IList.Contains(object value) + { + return (_values as IList).Contains(value); + } + + int IList.IndexOf(object value) + { + return (_values as IList).IndexOf(value); + } + + void IList.Insert(int index, object value) + { + (_values as IList).Insert(index, value); + } + + void IList.Remove(object value) + { + (_values as IList).Remove(value); + } + + void IList.RemoveAt(int index) + { + (_values as IList).RemoveAt(index); + } + + bool IList.IsFixedSize => false; + + object IList.this[int index] + { + get { return this[index]; } + set { (_values as IList)[index] = value; } + } + + #endregion + + #region IList<T> + + public int IndexOf(string item) + { + return _values.IndexOf(item); + } + + public void Insert(int index, string item) + { + _values.Insert(index, item); + } + + public void RemoveAt(int index) + { + _values.RemoveAt(index); + } + + void AssertValid(int index) + { + if (_c.Option == null) + throw new InvalidOperationException("OptionContext.Option is null."); + if (index >= _c.Option.MaxValueCount) + throw new ArgumentOutOfRangeException("index"); + if (_c.Option.OptionValueType == OptionValueType.Required && + index >= _values.Count) + { + throw new OptionException(string.Format( + _c.OptionSet.MessageLocalizer("Missing required value for option '{0}'."), _c.OptionName), + _c.OptionName); + } + } + + public string this[int index] + { + get + { + AssertValid(index); + return index >= _values.Count ? null : _values[index]; + } + set { _values[index] = value; } + } + + #endregion + } +}
\ No newline at end of file diff --git a/Xamarin.Forms.UITest.TestCloud/Mono.Options/OptionValueType.cs b/Xamarin.Forms.UITest.TestCloud/Mono.Options/OptionValueType.cs new file mode 100644 index 00000000..97ac0e9b --- /dev/null +++ b/Xamarin.Forms.UITest.TestCloud/Mono.Options/OptionValueType.cs @@ -0,0 +1,9 @@ +namespace Mono.Options +{ + public enum OptionValueType + { + None, + Optional, + Required + } +}
\ No newline at end of file diff --git a/Xamarin.Forms.UITest.TestCloud/Mono.Options/ResponseFileSource.cs b/Xamarin.Forms.UITest.TestCloud/Mono.Options/ResponseFileSource.cs new file mode 100644 index 00000000..881a384e --- /dev/null +++ b/Xamarin.Forms.UITest.TestCloud/Mono.Options/ResponseFileSource.cs @@ -0,0 +1,25 @@ +using System.Collections.Generic; + +namespace Mono.Options +{ + public class ResponseFileSource : ArgumentSource + { + public override string Description => "Read response file for more options."; + + public override string[] GetNames() + { + return new[] { "@file" }; + } + + public override bool GetArguments(string value, out IEnumerable<string> replacement) + { + if (string.IsNullOrEmpty(value) || !value.StartsWith("@")) + { + replacement = null; + return false; + } + replacement = GetArgumentsFromFile(value.Substring(1)); + return true; + } + } +}
\ No newline at end of file diff --git a/Xamarin.Forms.UITest.TestCloud/Mono.Options/StringCoda.cs b/Xamarin.Forms.UITest.TestCloud/Mono.Options/StringCoda.cs new file mode 100644 index 00000000..76eaf575 --- /dev/null +++ b/Xamarin.Forms.UITest.TestCloud/Mono.Options/StringCoda.cs @@ -0,0 +1,237 @@ +// +// Options.cs +// +// Authors: +// Jonathan Pryor <jpryor@novell.com> +// Federico Di Gregorio <fog@initd.org> +// Rolf Bjarne Kvinge <rolf@xamarin.com> +// +// Copyright (C) 2008 Novell (http://www.novell.com) +// Copyright (C) 2009 Federico Di Gregorio. +// Copyright (C) 2012 Xamarin Inc (http://www.xamarin.com) +// +// Permission is hereby granted, free of charge, to any person obtaining +// a copy of this software and associated documentation files (the +// "Software"), to deal in the Software without restriction, including +// without limitation the rights to use, copy, modify, merge, publish, +// distribute, sublicense, and/or sell copies of the Software, and to +// permit persons to whom the Software is furnished to do so, subject to +// the following conditions: +// +// The above copyright notice and this permission notice shall be +// included in all copies or substantial portions of the Software. +// +// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, +// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND +// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE +// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION +// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +// + +// Compile With: +// gmcs -debug+ -r:System.Core Options.cs -o:NDesk.Options.dll +// gmcs -debug+ -d:LINQ -r:System.Core Options.cs -o:NDesk.Options.dll +// +// The LINQ version just changes the implementation of +// OptionSet.Parse(IEnumerable<string>), and confers no semantic changes. + +// +// A Getopt::Long-inspired option parsing library for C#. +// +// NDesk.Options.OptionSet is built upon a key/value table, where the +// key is a option format string and the value is a delegate that is +// invoked when the format string is matched. +// +// Option format strings: +// Regex-like BNF Grammar: +// name: .+ +// type: [=:] +// sep: ( [^{}]+ | '{' .+ '}' )? +// aliases: ( name type sep ) ( '|' name type sep )* +// +// Each '|'-delimited name is an alias for the associated action. If the +// format string ends in a '=', it has a required value. If the format +// string ends in a ':', it has an optional value. If neither '=' or ':' +// is present, no value is supported. `=' or `:' need only be defined on one +// alias, but if they are provided on more than one they must be consistent. +// +// Each alias portion may also end with a "key/value separator", which is used +// to split option values if the option accepts > 1 value. If not specified, +// it defaults to '=' and ':'. If specified, it can be any character except +// '{' and '}' OR the *string* between '{' and '}'. If no separator should be +// used (i.e. the separate values should be distinct arguments), then "{}" +// should be used as the separator. +// +// Options are extracted either from the current option by looking for +// the option name followed by an '=' or ':', or is taken from the +// following option IFF: +// - The current option does not contain a '=' or a ':' +// - The current option requires a value (i.e. not a Option type of ':') +// +// The `name' used in the option format string does NOT include any leading +// option indicator, such as '-', '--', or '/'. All three of these are +// permitted/required on any named option. +// +// Option bundling is permitted so long as: +// - '-' is used to start the option group +// - all of the bundled options are a single character +// - at most one of the bundled options accepts a value, and the value +// provided starts from the next character to the end of the string. +// +// This allows specifying '-a -b -c' as '-abc', and specifying '-D name=value' +// as '-Dname=value'. +// +// Option processing is disabled by specifying "--". All options after "--" +// are returned by OptionSet.Parse() unchanged and unprocessed. +// +// Unprocessed options are returned from OptionSet.Parse(). +// +// Examples: +// int verbose = 0; +// OptionSet p = new OptionSet () +// .Add ("v", v => ++verbose) +// .Add ("name=|value=", v => Console.WriteLine (v)); +// p.Parse (new string[]{"-v", "--v", "/v", "-name=A", "/name", "B", "extra"}); +// +// The above would parse the argument string array, and would invoke the +// lambda expression three times, setting `verbose' to 3 when complete. +// It would also print out "A" and "B" to standard output. +// The returned array would contain the string "extra". +// +// C# 3.0 collection initializers are supported and encouraged: +// var p = new OptionSet () { +// { "h|?|help", v => ShowHelp () }, +// }; +// +// System.ComponentModel.TypeConverter is also supported, allowing the use of +// custom data types in the callback type; TypeConverter.ConvertFromString() +// is used to convert the value option to an instance of the specified +// type: +// +// var p = new OptionSet () { +// { "foo=", (Foo f) => Console.WriteLine (f.ToString ()) }, +// }; +// +// Random other tidbits: +// - Boolean options (those w/o '=' or ':' in the option format string) +// are explicitly enabled if they are followed with '+', and explicitly +// disabled if they are followed with '-': +// string a = null; +// var p = new OptionSet () { +// { "a", s => a = s }, +// }; +// p.Parse (new string[]{"-a"}); // sets v != null +// p.Parse (new string[]{"-a+"}); // sets v != null +// p.Parse (new string[]{"-a-"}); // sets v == null +// + +using System; +using System.Collections.Generic; + +#if LINQ +using System.Linq; +#endif + +#if TEST +using NDesk.Options; +#endif + +#if NDESK_OPTIONS +namespace NDesk.Options +#else + +namespace Mono.Options +#endif +{ + internal static class StringCoda + { + public static IEnumerable<string> WrappedLines(string self, params int[] widths) + { + IEnumerable<int> w = widths; + return WrappedLines(self, w); + } + + public static IEnumerable<string> WrappedLines(string self, IEnumerable<int> widths) + { + if (widths == null) + throw new ArgumentNullException("widths"); + return CreateWrappedLinesIterator(self, widths); + } + + static IEnumerable<string> CreateWrappedLinesIterator(string self, IEnumerable<int> widths) + { + if (string.IsNullOrEmpty(self)) + { + yield return string.Empty; + yield break; + } + using(IEnumerator<int> ewidths = widths.GetEnumerator()) + { + bool? hw = null; + int width = GetNextWidth(ewidths, int.MaxValue, ref hw); + int start = 0, end; + do + { + end = GetLineEnd(start, width, self); + char c = self[end - 1]; + if (char.IsWhiteSpace(c)) + --end; + bool needContinuation = end != self.Length && !IsEolChar(c); + string continuation = ""; + if (needContinuation) + { + --end; + continuation = "-"; + } + string line = self.Substring(start, end - start) + continuation; + yield return line; + start = end; + if (char.IsWhiteSpace(c)) + ++start; + width = GetNextWidth(ewidths, width, ref hw); + } while (start < self.Length); + } + } + + static int GetNextWidth(IEnumerator<int> ewidths, int curWidth, ref bool? eValid) + { + if (!eValid.HasValue || (eValid.HasValue && eValid.Value)) + { + curWidth = (eValid = ewidths.MoveNext()).Value ? ewidths.Current : curWidth; + // '.' is any character, - is for a continuation + const string minWidth = ".-"; + if (curWidth < minWidth.Length) + { + throw new ArgumentOutOfRangeException("widths", + string.Format("Element must be >= {0}, was {1}.", minWidth.Length, curWidth)); + } + return curWidth; + } + // no more elements, use the last element. + return curWidth; + } + + static bool IsEolChar(char c) + { + return !char.IsLetterOrDigit(c); + } + + static int GetLineEnd(int start, int length, string description) + { + int end = System.Math.Min(start + length, description.Length); + int sep = -1; + for (int i = start; i < end; ++i) + { + if (description[i] == '\n') + return i + 1; + if (IsEolChar(description[i])) + sep = i + 1; + } + if (sep == -1 || end == description.Length) + return end; + return sep; + } + } +}
\ No newline at end of file diff --git a/Xamarin.Forms.UITest.TestCloud/Properties/AssemblyInfo.cs b/Xamarin.Forms.UITest.TestCloud/Properties/AssemblyInfo.cs new file mode 100644 index 00000000..a88308b9 --- /dev/null +++ b/Xamarin.Forms.UITest.TestCloud/Properties/AssemblyInfo.cs @@ -0,0 +1,39 @@ +using System.Reflection; +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.UITest.TestCloud")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("Xamarin.Forms.UITest.TestCloud")] +[assembly: AssemblyCopyright("Copyright © 2016")] +[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("461f48a4-9e1c-4146-aa4e-ddd85746afc7")] + +// 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")]
\ No newline at end of file diff --git a/Xamarin.Forms.UITest.TestCloud/TestCloudUtils.cs b/Xamarin.Forms.UITest.TestCloud/TestCloudUtils.cs new file mode 100644 index 00000000..a554096f --- /dev/null +++ b/Xamarin.Forms.UITest.TestCloud/TestCloudUtils.cs @@ -0,0 +1,82 @@ +using System; +using System.Diagnostics; + +namespace Xamarin.Forms.UITest.TestCloud +{ + internal static class TestCloudUtils + { + public static bool IsRunningOnMono() + { + return Type.GetType("Mono.Runtime") != null; + } + + public static Tuple<DeviceSet.Platform, string> ParseArgs(string input) + { + string[] deviceArgs = input.Split(new[] { " " }, StringSplitOptions.RemoveEmptyEntries); + if (deviceArgs.Length != 2) + { + Console.WriteLine("!!! Invalid upload paramters, should be <Platform> <Category> : You entered : " + input); + return null; + } + + DeviceSet.Platform platform = deviceArgs[0] == "Android" ? DeviceSet.Platform.Android : DeviceSet.Platform.IOs; + string category = deviceArgs[1]; + + return Tuple.Create(platform, category); + } + + public static int UploadApp(string command) + { + Tuple<string, string> execArgsPair = IsRunningOnMono() ? MonoExecArgs(command) : WindowsExecArgs(command); + + var process = new Process + { + StartInfo = new ProcessStartInfo + { + FileName = execArgsPair.Item1, + Arguments = execArgsPair.Item2, + UseShellExecute = false, + RedirectStandardOutput = true, + RedirectStandardError = true, + CreateNoWindow = true + } + }; + + try + { + process.Start(); + } + catch (Exception e) + { + Console.WriteLine(e.Message); + return 1; + } + + while (!process.StandardOutput.EndOfStream) + { + string line = process.StandardOutput.ReadLine(); + Console.WriteLine(line); + } + while (!process.StandardError.EndOfStream) + { + string line = process.StandardError.ReadLine(); + Console.WriteLine(line); + } + process.WaitForExit(); + return process.ExitCode; + } + + static Tuple<string, string> MonoExecArgs(string command) + { + return Tuple.Create("mono", command); + } + + static Tuple<string, string> WindowsExecArgs(string command) + { + string[] commandArray = command.Split(' '); + string executable = commandArray[0]; + string uploadCommand = string.Join(" ", commandArray, 1, commandArray.Length - 1); + return Tuple.Create(executable, uploadCommand); + } + } +}
\ No newline at end of file diff --git a/Xamarin.Forms.UITest.TestCloud/Uploader.cs b/Xamarin.Forms.UITest.TestCloud/Uploader.cs new file mode 100644 index 00000000..b0cf299c --- /dev/null +++ b/Xamarin.Forms.UITest.TestCloud/Uploader.cs @@ -0,0 +1,409 @@ +using System; +using System.Collections.Generic; +using System.IO; +using System.Linq; +using System.Security.Policy; +using System.Text; +using Mono.Options; +using Xamarin.Forms.Core.UITests; +using Xamarin.Forms.Loader; + +namespace Xamarin.Forms.UITest.TestCloud +{ + // TODO: Provide way to construct url for results easy access + + static class Uploader + { + static LoaderActions loaderActions; + + static int Main(string[] args) + { + loaderActions = new LoaderActions(); + + var categories = new List<string>(); + string series = null; + var platform = DeviceSet.Platform.None; + DeviceSet deviceSet = null; + var validate = false; + string outputFile = null; + var account = ""; + var user = ""; + + OptionSet optionSet = null; + optionSet = new OptionSet + { + { + "p|platform=", "specify the test platform, iOS or Android", + s => platform = (DeviceSet.Platform)Enum.Parse(typeof (DeviceSet.Platform), s) + }, + { "d|deviceset=", "the device set to use for the test run", s => deviceSet = StringToDeviceSet(s) }, + { "c|category=", "add a category to the test run", s => categories.Add(s) }, + { "s|series=", "specify the series when uploaded to Test Cloud", s => series = s }, + { "l|list", "list categories available in test suite", ListCategories }, + { "sets", "list available device sets", ListDeviceSets }, + { "i|interactive", "start uploader in interactive mode", InteractiveMode }, + { "h|help", "show this message and exit", s => ShowHelp(optionSet) }, + { "v|validate", "validate all tests or a specified category", s => validate = true }, + { "o|output=", "output destination for NUnit XML", s => outputFile = s }, + { "a|account=", "Test Cloud key", s => account = s }, + { "u|user=", "Test Cloud user", s => user = s } + }; + + List<string> extra; + try + { + extra = optionSet.Parse(args); + } + catch (OptionException ex) + { + Console.Write("Uploader:"); + Console.WriteLine(ex.Message); + Console.WriteLine("Try --help for more informaiton"); + } + + if (args.Length == 0) + ShowHelp(optionSet); + + if (validate) + { + var category = categories.FirstOrDefault(); + return loaderActions.ValidateCategory(category) ? 0 : 1; + } + + if (platform == DeviceSet.Platform.None) + { + Console.WriteLine("Platform must be specified"); + return 1; + } + + if (deviceSet != null && !deviceSet.DeviceSetPlatform.Contains(platform)) + { + Console.WriteLine("DeviceSet platform does not match specified platform"); + return 1; + } + + if (deviceSet == null) + { + if (platform == DeviceSet.Platform.Android) + deviceSet = DeviceSets.AndroidFastParallel; + else + deviceSet = DeviceSets.IOsFastParallel; + } + + var execString = BuildExecutionString(platform, deviceSet, categories, series, account, user, outputFile); + + Console.WriteLine(execString); + + var processStatus = TestCloudUtils.UploadApp(execString); + + Console.WriteLine("test-cloud.exe status: " + processStatus); + return processStatus; + } + + static string BuildExecutionString(DeviceSet.Platform platform, DeviceSet deviceSet, IEnumerable<string> categories, + string series, string account, string user, string outputFile = null) + { + var stringBuilder = new StringBuilder(); + stringBuilder.Append(ConsolePath); + stringBuilder.Append(" submit "); + + switch (platform) + { + case DeviceSet.Platform.Android: + stringBuilder.Append(ApkPath); + break; + case DeviceSet.Platform.IOs: + stringBuilder.Append(IpaPath); + break; + case DeviceSet.Platform.IOsClassic: + stringBuilder.Append(IpaClassicPath); + break; + } + + stringBuilder.Append(" "); + stringBuilder.Append(account); + stringBuilder.Append(" --user "); + stringBuilder.Append(user); + stringBuilder.Append(" --devices "); + stringBuilder.Append(deviceSet.Id); + + foreach (var category in categories) + { + stringBuilder.Append(" --include "); + stringBuilder.Append(category); + } + + if (!string.IsNullOrEmpty(series)) + { + stringBuilder.Append(" --series "); + stringBuilder.Append(series); + } + + stringBuilder.Append(" --locale \"en_US\""); + + switch (platform) + { + case DeviceSet.Platform.Android: + stringBuilder.Append(" --app-name \"AndroidControlGallery\""); + break; + case DeviceSet.Platform.IOs: + case DeviceSet.Platform.IOsClassic: + stringBuilder.Append(" --app-name \"XamControl\""); + break; + } + + stringBuilder.Append(" --assembly-dir "); + + if (platform == DeviceSet.Platform.Android) + stringBuilder.Append(AndroidTestingDirectory); + else + stringBuilder.Append(iOSTestingDirectory); + + stringBuilder.Append(" --fixture-chunk"); + + if (!string.IsNullOrEmpty(outputFile)) + stringBuilder.Append($" --nunit-xml {outputFile}"); + + return stringBuilder.ToString(); + } + + static void InteractiveMode(string s) + { + Console.WriteLine("Interactive testcloud uploader. Type --help for help"); + Console.WriteLine( + "Usage: >>> -d <deviceset> -c <category> -a <key> -u <user> [-c <category> -c <category> -c <category>]"); + + while (true) + { + Console.Write(">>> "); + var command = Console.ReadLine(); + var commandList = command.Split(' '); + + var platform = DeviceSet.Platform.None; + var deviceSet = ""; + var categories = new List<string>(); + var series = ""; + var account = ""; + var user = ""; + + OptionSet options = null; + options = new OptionSet + { + { "q|quit", "quit", Exit }, + { "h|help", "show this message and exit", str => ShowInteractiveHelp(options) }, + { "c|category=", "specify the category to run in Test cloud", str => categories.Add(str) }, + { "d|deviceset=", "specify the device set to upload", str => deviceSet = str }, + { "lc|listcategories", "Lists categories in uitests", ListCategories }, + { "ld|listdevicesets", "Lists defined devices sets", ListDeviceSets }, + { "a|account=", "Test Cloud key", str => account = str }, + { "u|user=", "Test Cloud user", str => user = str } + }; + + List<string> extra; + try + { + extra = options.Parse(commandList); + } + catch (OptionException ex) + { + Console.Write("Uploader:"); + Console.WriteLine(ex.Message); + Console.WriteLine("Try --help for more informaiton"); + } + + if (command.Length == 0) + ShowHelp(options); + + // by default take the first category as the series name + if (categories.Count >= 1) + series = categories.First(); + + if (commandList.Length >= 4) + { + var validQuery = true; + + if (!IsValidDeviceSet(deviceSet)) + { + Console.WriteLine("Invalid DeviceSet: {0}", deviceSet); + validQuery = false; + } + + if (!CategoriesValid(categories)) + { + Console.Write("Invalid Category(s):"); + foreach (var c in categories) + Console.Write(" {0} ", c); + Console.Write("\n"); + validQuery = false; + } + + if (validQuery) + { + var devSet = StringToDeviceSet(deviceSet); + var execString = BuildExecutionString(devSet.DeviceSetPlatform.First(), devSet, categories, series, account, user); + Console.WriteLine(execString); + TestCloudUtils.UploadApp(execString); + } + } + } + } + + static void ShowInteractiveHelp(OptionSet options) + { + Console.WriteLine("Usage: [OPTIONS]"); + Console.WriteLine(); + Console.WriteLine("Options:"); + options.WriteOptionDescriptions(Console.Out); + } + + static void Exit(string s) + { + Environment.Exit(0); + } + + static void ShowHelp(OptionSet options) + { + Console.WriteLine("Usage: Uploader [OPTIONS]"); + Console.WriteLine(); + Console.WriteLine("Options:"); + options.WriteOptionDescriptions(Console.Out); + + Environment.Exit(0); + } + + static DeviceSet StringToDeviceSet(string s) + { + try + { + var device = (DeviceSet)typeof (DeviceSets).GetField(s).GetValue(null); + return device; + } + catch (Exception ex) + { + Console.WriteLine("DeviceSet not found"); + return null; + } + } + + static void ListDeviceSets(string s) + { + var deviceSetsType = typeof (DeviceSets); + + var fields = deviceSetsType.GetFields(); + + foreach (var field in fields) + Console.WriteLine(field.Name); + } + + static void ListCategories(string s) + { + loaderActions.ListCategories(); + } + + static bool CategoriesValid(List<string> categories) + { + var areValid = true; + + if (categories.Count < 1) + return false; + + foreach (var category in categories) + { + if (!loaderActions.ValidateCategory(category)) + return false; + } + + return areValid; + } + + static bool IsValidDeviceSet(string deviceSet) + { + var deviceSetsType = typeof (DeviceSets); + var isValid = deviceSetsType.GetFields().Any(ds => ds.Name == deviceSet); + return isValid; + } + + public static string ConsolePath + { + get + { + string[] consolePathElements = { "..", "..", "..", "packages", "Xamarin.UITest.1.3.3", "tools", "test-cloud.exe" }; + return Path.Combine(consolePathElements); + } + } + + public static string IpaPath + { + get + { + string[] ipaPathElements = + { + "..", + "..", + "..", + "Xamarin.Forms.ControlGallery.iOS", + "bin", + "iPhone", + "Debug", + "XamarinFormsControlGalleryiOS-1.0.ipa" + }; + return Path.Combine(ipaPathElements); + } + } + + public static string IpaClassicPath + { + get + { + string[] ipaPathElements = + { + "..", + "..", + "..", + "Xamarin.Forms.ControlGallery.iOS", + "classic_bin", + "iPhone", + "Debug", + "XamarinFormsControlGalleryiOS-1.0.ipa" + }; + return Path.Combine(ipaPathElements); + } + } + + public static string ApkPath + { + get + { + string[] apkPathElements = + { + "..", + "..", + "..", + "Xamarin.Forms.ControlGallery.Android", + "bin", + "Debug", + "AndroidControlGallery.AndroidControlGallery-Signed.apk" + }; + return Path.Combine(apkPathElements); + } + } + + public static string iOSTestingDirectory + { + get + { + string[] testDiriOSPathElements = { "..", "..", "..", "Xamarin.Forms.Core.iOS.UITests", "bin", "Debug" }; + return Path.Combine(testDiriOSPathElements); + } + } + + public static string AndroidTestingDirectory + { + get + { + string[] testDirAndroidPathElements = { "..", "..", "..", "Xamarin.Forms.Core.Android.UITests", "bin", "Debug" }; + return Path.Combine(testDirAndroidPathElements); + } + } + } +} diff --git a/Xamarin.Forms.UITest.TestCloud/Xamarin.Forms.UITest.TestCloud.csproj b/Xamarin.Forms.UITest.TestCloud/Xamarin.Forms.UITest.TestCloud.csproj new file mode 100644 index 00000000..86f62324 --- /dev/null +++ b/Xamarin.Forms.UITest.TestCloud/Xamarin.Forms.UITest.TestCloud.csproj @@ -0,0 +1,156 @@ +<?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>{1E238A01-B492-461F-BADE-415E8F9C5DFC}</ProjectGuid> + <OutputType>Exe</OutputType> + <AppDesignerFolder>Properties</AppDesignerFolder> + <RootNamespace>Xamarin.Forms.UITest.TestCloud</RootNamespace> + <AssemblyName>Xamarin.Forms.UITest.TestCloud</AssemblyName> + <TargetFrameworkVersion>v4.5</TargetFrameworkVersion> + <FileAlignment>512</FileAlignment> + <SolutionDir Condition="$(SolutionDir) == '' Or $(SolutionDir) == '*Undefined*'">..\</SolutionDir> + <RestorePackages>true</RestorePackages> + <PublishUrl>publish\</PublishUrl> + <Install>true</Install> + <InstallFrom>Disk</InstallFrom> + <UpdateEnabled>false</UpdateEnabled> + <UpdateMode>Foreground</UpdateMode> + <UpdateInterval>7</UpdateInterval> + <UpdateIntervalUnits>Days</UpdateIntervalUnits> + <UpdatePeriodically>false</UpdatePeriodically> + <UpdateRequired>false</UpdateRequired> + <MapFileExtensions>true</MapFileExtensions> + <ApplicationRevision>0</ApplicationRevision> + <ApplicationVersion>1.0.0.%2a</ApplicationVersion> + <IsWebBootstrapper>false</IsWebBootstrapper> + <UseApplicationTrust>false</UseApplicationTrust> + <BootstrapperEnabled>true</BootstrapperEnabled> + </PropertyGroup> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' "> + <PlatformTarget>AnyCPU</PlatformTarget> + <DebugSymbols>true</DebugSymbols> + <DebugType>full</DebugType> + <Optimize>false</Optimize> + <OutputPath>bin\Debug\</OutputPath> + <DefineConstants>DEBUG;TRACE</DefineConstants> + <ErrorReport>prompt</ErrorReport> + <WarningLevel>4</WarningLevel> + </PropertyGroup> + <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' "> + <PlatformTarget>AnyCPU</PlatformTarget> + <DebugType>pdbonly</DebugType> + <Optimize>true</Optimize> + <OutputPath>bin\Release\</OutputPath> + <DefineConstants>TRACE</DefineConstants> + <ErrorReport>prompt</ErrorReport> + <WarningLevel>4</WarningLevel> + </PropertyGroup> + <PropertyGroup Condition="'$(Configuration)|$(Platform)' == 'Turkey|AnyCPU'"> + <DebugSymbols>true</DebugSymbols> + <OutputPath>bin\Turkey\</OutputPath> + <DefineConstants>DEBUG;TRACE</DefineConstants> + <DebugType>full</DebugType> + <PlatformTarget>AnyCPU</PlatformTarget> + <ErrorReport>prompt</ErrorReport> + <CodeAnalysisRuleSet>MinimumRecommendedRules.ruleset</CodeAnalysisRuleSet> + <Prefer32Bit>true</Prefer32Bit> + </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> + </ItemGroup> + <ItemGroup> + <Compile Include="DeviceSet.cs" /> + <Compile Include="DeviceSets.cs" /> + <Compile Include="LoaderActions.cs" /> + <Compile Include="Uploader.cs" /> + <Compile Include="Mono.Options\ArgumentSource.cs" /> + <Compile Include="Mono.Options\Option.cs" /> + <Compile Include="Mono.Options\OptionAction.cs" /> + <Compile Include="Mono.Options\OptionContext.cs" /> + <Compile Include="Mono.Options\OptionException.cs" /> + <Compile Include="Mono.Options\StringCoda.cs" /> + <Compile Include="Mono.Options\OptionSet.cs" /> + <Compile Include="Mono.Options\OptionValueCollection.cs" /> + <Compile Include="Mono.Options\OptionValueType.cs" /> + <Compile Include="Mono.Options\ResponseFileSource.cs" /> + <Compile Include="Properties\AssemblyInfo.cs" /> + <Compile Include="TestCloudUtils.cs" /> + </ItemGroup> + <ItemGroup> + <None Include="App.config" /> + <None Include="packages.config" /> + </ItemGroup> + <ItemGroup> + <ProjectReference Include="..\Xamarin.Forms.Core.Android.UITests\Xamarin.Forms.Core.Android.UITests.csproj"> + <Project>{a34ebe01-25bf-4e69-a2dc-2288dc625541}</Project> + <Name>Xamarin.Forms.Core.Android.UITests</Name> + </ProjectReference> + <ProjectReference Include="..\Xamarin.Forms.Core.iOS.UITests\Xamarin.Forms.Core.iOS.UITests.csproj"> + <Project>{eadd8100-b3ae-4a31-92c4-267a64a1c6eb}</Project> + <Name>Xamarin.Forms.Core.iOS.UITests</Name> + </ProjectReference> + <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.Loader\Xamarin.Forms.Loader.csproj"> + <Project>{00211725-2f89-4e2c-ac5a-38e5ff61be67}</Project> + <Name>Xamarin.Forms.Loader</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> + <Folder Include="Logs\" /> + </ItemGroup> + <ItemGroup> + <BootstrapperPackage Include=".NETFramework,Version=v4.5"> + <Visible>False</Visible> + <ProductName>Microsoft .NET Framework 4.5 %28x86 and x64%29</ProductName> + <Install>true</Install> + </BootstrapperPackage> + <BootstrapperPackage Include="Microsoft.Net.Client.3.5"> + <Visible>False</Visible> + <ProductName>.NET Framework 3.5 SP1 Client Profile</ProductName> + <Install>false</Install> + </BootstrapperPackage> + <BootstrapperPackage Include="Microsoft.Net.Framework.3.5.SP1"> + <Visible>False</Visible> + <ProductName>.NET Framework 3.5 SP1</ProductName> + <Install>false</Install> + </BootstrapperPackage> + </ItemGroup> + <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> + --> +</Project>
\ No newline at end of file diff --git a/Xamarin.Forms.UITest.TestCloud/packages.config b/Xamarin.Forms.UITest.TestCloud/packages.config new file mode 100644 index 00000000..d18b935f --- /dev/null +++ b/Xamarin.Forms.UITest.TestCloud/packages.config @@ -0,0 +1,5 @@ +<?xml version="1.0" encoding="utf-8"?> +<packages> + <package id="Mono.Options" version="1.1" targetFramework="net45" /> + <package id="NUnit" version="2.6.4" targetFramework="net45" /> +</packages>
\ No newline at end of file |