public void ConstructorWithMessageAndInnerExceptionWorks() {
			var inner = new Exception("a");
			var ex = new FormatException("The message", inner);
			Assert.IsTrue((object)ex is FormatException, "is FormatException");
			Assert.IsTrue(ReferenceEquals(ex.InnerException, inner), "InnerException");
			Assert.AreEqual(ex.Message, "The message");
		}

        public static void InstantiateException()
        {
            int error = 5;
            string message = "This is an error message.";
            Exception innerException = new FormatException();

            // Test each of the constructors and validate the properties of the resulting instance

            Win32Exception ex = new Win32Exception();
            Assert.Equal(expected: E_FAIL, actual: ex.HResult);

            ex = new Win32Exception(error);
            Assert.Equal(expected: E_FAIL, actual: ex.HResult);
            Assert.Equal(expected: error, actual: ex.NativeErrorCode);

            ex = new Win32Exception(message);
            Assert.Equal(expected: E_FAIL, actual: ex.HResult);
            Assert.Equal(expected: message, actual: ex.Message);

            ex = new Win32Exception(error, message);
            Assert.Equal(expected: E_FAIL, actual: ex.HResult);
            Assert.Equal(expected: error, actual: ex.NativeErrorCode);
            Assert.Equal(expected: message, actual: ex.Message);

            ex = new Win32Exception(message, innerException);
            Assert.Equal(expected: E_FAIL, actual: ex.HResult);
            Assert.Equal(expected: message, actual: ex.Message);
            Assert.Same(expected: innerException, actual: ex.InnerException);
        }

 public void ConstructorWithMessageWorks()
 {
     var ex = new FormatException("The message");
     Assert.True((object)ex is FormatException, "is FormatException");
     Assert.AreEqual(ex.InnerException, null, "InnerException");
     Assert.AreEqual(ex.Message, "The message");
 }

 public void DefaultConstructorWorks()
 {
     var ex = new FormatException();
     Assert.True((object)ex is FormatException, "is FormatException");
     Assert.AreEqual(ex.InnerException, null, "InnerException");
     Assert.AreEqual(ex.Message, "Invalid format.");
 }

 public void TypePropertiesAreCorrect()
 {
     Assert.AreEqual(typeof(FormatException).GetClassName(), "Bridge.FormatException", "Name");
     object d = new FormatException();
     Assert.True(d is FormatException, "is FormatException");
     Assert.True(d is Exception, "is Exception");
 }

        public override object ConvertFrom(ITypeDescriptorContext context, CultureInfo culture, object value)
        {
            var stringValue = value as string;
            if (stringValue != null)
            {
                var input = stringValue.Trim();

                if (string.IsNullOrEmpty(input))
                {
                    return value;
                }

                // Try to parse. Use the invariant culture instead of the current one.
                TimeSpan timeSpan;
                if (TimeSpan.TryParse(input, CultureInfo.InvariantCulture, out timeSpan))
                {
                    return value;
                }

                var exception = new FormatException(string.Format(CultureInfo.CurrentCulture, Resources.TimeSpanConverter_InvalidString, stringValue));
                throw exception;
            }

            return base.ConvertFrom(context, culture, value);
        }

        internal static string AddParameter (string baseUrl, string parameter, string value)
        {
            // this will get our url's properly formatted
            if (parameter == Constants.UrlParameter.Url)
            {
                try
                {
                    value = new Uri (value).ToString();
                }
                catch (System.FormatException e)  //UriFormatException is not supported in the portable libraries
                {
                    FormatException ufe = new FormatException("Delicious.Net was unable to parse the url \"" + value + "\".\n\n" + e);
                    throw (ufe);
                }
            }
            value = Uri.EscapeDataString(value); //HttpUtility.UrlEncode  is not supported in the portable libraries

            // insert the '?' if needed
            int qLocation = baseUrl.LastIndexOf ('?');
            if (qLocation < 0)
            {
                baseUrl += "?";
                qLocation = baseUrl.Length - 1;
            }

            if (baseUrl.Length > qLocation + 1)
                baseUrl += "&";

            baseUrl += parameter + "=" + value;
            return baseUrl;
        }

        public void TestWhenAny1_Canceled1_Faulted1()
        {
            Exception expectedException = new FormatException();
            Action<Task> exceptionSelector =
                task =>
                {
                    throw expectedException;
                };
            IEnumerable<Task> tasks =
                new[]
                {
                    DelayedTask.Delay(TimeSpan.FromMilliseconds(1 * TimingGranularity.TotalMilliseconds)).Then(_ => CompletedTask.Canceled()),
                    DelayedTask.Delay(TimeSpan.FromMilliseconds(3 * TimingGranularity.TotalMilliseconds)).Select(exceptionSelector).ObserveExceptions()
                };
            Task<Task> delayed = DelayedTask.WhenAny(tasks);
            Assert.IsFalse(delayed.IsCompleted);

            delayed.Wait();
            Assert.IsTrue(delayed.IsCompleted);
            Assert.AreEqual(TaskStatus.RanToCompletion, delayed.Status);
            Assert.IsNotNull(delayed.Result);
            Assert.IsTrue(tasks.Contains(delayed.Result));

            // this one was the first to complete
            Assert.IsTrue(delayed.Result.IsCompleted);
            Assert.IsTrue(delayed.Result.IsCanceled);
            Assert.AreEqual(TaskStatus.Canceled, delayed.Result.Status);
        }

 internal static void DisplayException(FormatException exception)
 {
     var title = "Format exception";
     StringBuilder content = new StringBuilder();
     content.AppendLine("There is a problem with the format of the message:");
     content.AppendFormat("Exception: {0}\n\n", exception.Message);
     MessageDialogHelper.ShowDialogAsync(content.ToString(), title);
 }

 public void InvariantWithLambdaMessageAndInnerThrowsCorrectly()
 {
     FormatException inner = new FormatException();
     Assert.That(() => Check.Invariant(-1, i => i > 0, InvariantMessage, inner),
                 Throws.TypeOf<InvariantException>()
                     .With.Message.ContainsSubstring(InvariantMessage)
                     .And.Property("InnerException").EqualTo(inner));
 }

 public void AssertionWithMessageAndInnerThrowsCorrectly()
 {
     FormatException inner = new FormatException();
     Assert.That(() => Check.Assert(false, AssertionMessage, inner),
                 Throws.TypeOf<AssertionException>()
                     .With.Message.ContainsSubstring(AssertionMessage)
                     .And.Property("InnerException").EqualTo(inner));
 }

 public void PostconditionWithLambdaMessageAndInnerThrowsCorrectly()
 {
     FormatException inner = new FormatException();
     Assert.That(() => Check.Ensure(-1, i => i > 0, PostconditionMessage, inner),
                 Throws.TypeOf<PostconditionException>()
                     .With.Message.ContainsSubstring(PostconditionMessage)
                     .And.Property("InnerException").EqualTo(inner));
 }

 public static void InputNotANumberLog(FormatException e)
 {
     List<string> log = new List<string>();
     log.Add("InputNotANumberError");
     log.Add("Fehlermeldung: " + e.Message);
     log.Add("Fehler bei der Auswahl des Songs.");
     log.Add("Fehlerbehebung: Programm mit Song erneut starten, nur 1, 2 oder 3 eingeben.");
     Errorlogs.PrintLogs(log);
 }

            public void ShouldFlattenTheException()
            {
                var formatException = new FormatException("FormatException Message");
                var argumentNullException = new ArgumentNullException("ArgumentNullException Message", formatException);
                var exception = new Exception("Exception Message", argumentNullException);
                var exceptionFlatten = exception.Flatten();

                const string messageExpected = "Exception Message\r\nArgumentNullException Message\r\nFormatException Message\r\n";

                Assert.AreEqual(messageExpected, exceptionFlatten);
            }

            public void ShouldFindTheSpecifiedException()
            {
                var formatException = new FormatException();
                var argumentNullException = new ArgumentNullException("", formatException);
                var exception = new Exception("", argumentNullException);

                var foundException = exception.Find<ArgumentNullException>();

                Assert.IsNotNull(foundException);
                Assert.IsInstanceOf(typeof(ArgumentNullException), foundException);
            }

		public void TypePropertiesAreCorrect() {
			Assert.AreEqual(typeof(FormatException).FullName, "ss.FormatException", "Name");
			Assert.IsTrue(typeof(FormatException).IsClass, "IsClass");
			Assert.AreEqual(typeof(FormatException).BaseType, typeof(Exception), "BaseType");
			object d = new FormatException();
			Assert.IsTrue(d is FormatException, "is FormatException");
			Assert.IsTrue(d is Exception, "is Exception");

			var interfaces = typeof(FormatException).GetInterfaces();
			Assert.AreEqual(interfaces.Length, 0, "Interfaces length");
		}

		private static void ThrowInformativeException(string when, string[] formats, FormatException e)
		{
			var builder = new StringBuilder();
			builder.AppendFormat("One of the date fields contained a date/time format which could not be parsed ({0})." + Environment.NewLine, when);
			builder.Append("This program can parse the following formats: ");
			foreach (var format in formats)
			{
				builder.Append(format + Environment.NewLine);
			}
			builder.Append("See: http://en.wikipedia.org/wiki/ISO_8601 for an explanation of these symbols.");
			throw new ApplicationException(builder.ToString(), e);
		}

 private Collection<AliasInfo> GetAliasesFromFile(bool isLiteralPath)
 {
     Collection<AliasInfo> collection = new Collection<AliasInfo>();
     string filePath = null;
     using (StreamReader reader = this.OpenFile(out filePath, isLiteralPath))
     {
         CSVHelper helper = new CSVHelper(',');
         long num = 0L;
         string line = null;
         while ((line = reader.ReadLine()) != null)
         {
             num += 1L;
             if (((line.Length != 0) && !OnlyContainsWhitespace(line)) && (line[0] != '#'))
             {
                 Collection<string> collection2 = helper.ParseCsv(line);
                 if (collection2.Count != 4)
                 {
                     string message = StringUtil.Format(AliasCommandStrings.ImportAliasFileInvalidFormat, filePath, num);
                     FormatException exception = new FormatException(message);
                     ErrorRecord errorRecord = new ErrorRecord(exception, "ImportAliasFileFormatError", ErrorCategory.ReadError, filePath) {
                         ErrorDetails = new ErrorDetails(message)
                     };
                     base.ThrowTerminatingError(errorRecord);
                 }
                 ScopedItemOptions none = ScopedItemOptions.None;
                 try
                 {
                     none = (ScopedItemOptions) Enum.Parse(typeof(ScopedItemOptions), collection2[3], true);
                 }
                 catch (ArgumentException exception2)
                 {
                     string str4 = StringUtil.Format(AliasCommandStrings.ImportAliasOptionsError, filePath, num);
                     ErrorRecord record2 = new ErrorRecord(exception2, "ImportAliasOptionsError", ErrorCategory.ReadError, filePath) {
                         ErrorDetails = new ErrorDetails(str4)
                     };
                     base.WriteError(record2);
                     continue;
                 }
                 AliasInfo item = new AliasInfo(collection2[0], collection2[1], base.Context, none);
                 if (!string.IsNullOrEmpty(collection2[2]))
                 {
                     item.Description = collection2[2];
                 }
                 collection.Add(item);
             }
         }
         reader.Close();
     }
     return collection;
 }

 public void InnerExceptions()
 {
     Exception inner = new FormatException();
     ApplicationException outer = new ApplicationException(null, inner);
     JsonObject error = JsonRpcError.FromException(ThrowAndCatch(outer));
     JsonArray errors = (JsonArray) error["errors"];
     Assert.AreEqual(2, errors.Count);
     error = (JsonObject) errors.Shift();
     Assert.AreEqual(outer.Message, error["message"]);
     Assert.AreEqual("ApplicationException", error["name"]);
     error = (JsonObject) errors.Shift();
     Assert.AreEqual(inner.Message, error["message"]);
     Assert.AreEqual("FormatException", error["name"]);
 }

        public void TestWhenAll1_Canceled1_Faulted1()
        {
            Exception expectedException = new FormatException();
            Action<Task> exceptionSelector =
                task =>
                {
                    throw expectedException;
                };
            IEnumerable<Task> tasks =
                new[]
                {
                    DelayedTask.Delay(TimeSpan.FromMilliseconds(1 * TimingGranularity.TotalMilliseconds)).Then(_ => CompletedTask.Canceled()),
                    DelayedTask.Delay(TimeSpan.FromMilliseconds(3 * TimingGranularity.TotalMilliseconds)).Select(exceptionSelector)
                };
            Task delayed = DelayedTask.WhenAll(tasks);
            Assert.IsFalse(delayed.IsCompleted);

            try
            {
                delayed.Wait();
                Assert.Fail("Expected an exception");
            }
            catch (AggregateException ex)
            {
                Assert.AreEqual(TaskStatus.Faulted, delayed.Status);
                Assert.AreEqual(1, ex.InnerExceptions.Count);
                foreach (Exception innerException in ex.InnerExceptions)
                {
                    Assert.AreSame(expectedException, innerException);
                }
            }

            Assert.IsTrue(delayed.IsCompleted);
            Assert.IsTrue(delayed.IsFaulted);
            Assert.AreEqual(TaskStatus.Faulted, delayed.Status);

            Task firstTask = tasks.ElementAt(0);
            Assert.IsTrue(firstTask.IsCompleted);
            Assert.IsTrue(firstTask.IsCanceled);
            Assert.AreEqual(TaskStatus.Canceled, firstTask.Status);

            Task secondTask = tasks.ElementAt(1);
            Assert.IsTrue(secondTask.IsCompleted);
            Assert.IsTrue(secondTask.IsFaulted);
            Assert.AreEqual(TaskStatus.Faulted, secondTask.Status);
            Assert.IsNotNull(secondTask.Exception);
            Assert.AreEqual(1, secondTask.Exception.InnerExceptions.Count);
            Assert.AreSame(expectedException, secondTask.Exception.InnerExceptions[0]);
        }