public void TestAppealToMigrateFromChatId()
        {
            SendMessageResult sendMessage = mTelegramBot.SendMessage(mChatId, "TestAppealToMigrateFromChatId()");

            var migrateFromChatId = sendMessage.Result.MigrateFromChatId;

            ConsoleUtlis.PrintSimpleResult(migrateFromChatId);

            Assert.Multiple(() =>
            {
                Assert.True(sendMessage.Ok);

                Assert.IsInstanceOf(typeof(int), migrateFromChatId);
                Assert.AreEqual(migrateFromChatId, 0);
            });
        }
        public void TestAppealToTheEmptyForwardSignatureMessageId()
        {
            SendMessageResult sendMessage = mTelegramBot.SendMessage(mChatId, "TestAppealToTheEmptyForwardSignature()");

            var forwardSignature = sendMessage.Result.ForwardSignature;

            ConsoleUtlis.PrintSimpleResult(forwardSignature);

            Assert.Multiple(() =>
            {
                Assert.True(sendMessage.Ok);

                Assert.IsInstanceOf(typeof(string), forwardSignature);
                Assert.AreEqual(forwardSignature, string.Empty);
            });
        }
        public void TestAppealToChannelChatCreated()
        {
            SendMessageResult sendMessage = mTelegramBot.SendMessage(mChatId, "TestAppealToChannelChatCreated()");

            var channelChatCreated = sendMessage.Result.ChannelChatCreated;

            ConsoleUtlis.PrintSimpleResult(channelChatCreated);

            Assert.Multiple(() =>
            {
                Assert.True(sendMessage.Ok);

                Assert.IsInstanceOf(typeof(bool), channelChatCreated);
                Assert.IsFalse(channelChatCreated);
            });
        }
        public void TestAppealToTheEmptyForwardFromMessageId()
        {
            SendMessageResult sendMessage = mTelegramBot.SendMessage(mChatId, "TestAppealToTheEmptyForwardFromMessageId()");

            var forwardFromMessageId = sendMessage.Result.ForwardFromMessageId;

            ConsoleUtlis.PrintSimpleResult(forwardFromMessageId);

            Assert.Multiple(() =>
            {
                Assert.True(sendMessage.Ok);

                Assert.IsInstanceOf(typeof(int), forwardFromMessageId);
                Assert.AreEqual(forwardFromMessageId, 0);
            });
        }
        public void TestAppealToTheEmptyDeleteChatPhoto()
        {
            SendMessageResult sendMessage = mTelegramBot.SendMessage(mChatId, "TestAppealToTheEmptyDeleteChatPhoto()");

            var deleteChatPhoto = sendMessage.Result.DeleteChatPhoto;

            ConsoleUtlis.PrintSimpleResult(deleteChatPhoto);

            Assert.Multiple(() =>
            {
                Assert.True(sendMessage.Ok);

                Assert.IsInstanceOf(typeof(bool), deleteChatPhoto);
                Assert.IsFalse(deleteChatPhoto);
            });
        }
        public void TestAppealToAuthorSignature()
        {
            SendMessageResult sendMessage = mTelegramBot.SendMessage(mChatId, "TestAppealToMigrateFromEditDateUnix()");

            var authorSignature = sendMessage.Result.AuthorSignature;

            ConsoleUtlis.PrintSimpleResult(authorSignature);

            Assert.Multiple(() =>
            {
                Assert.True(sendMessage.Ok);

                Assert.IsInstanceOf(typeof(string), authorSignature);
                Assert.AreEqual(authorSignature, string.Empty);
            });
        }
        public void TestAppealToMigrateFromEditDateUnix()
        {
            SendMessageResult sendMessage = mTelegramBot.SendMessage(mChatId, "TestAppealToMigrateFromEditDateUnix()");

            var editDateUnix = sendMessage.Result.EditDateUnix;

            ConsoleUtlis.PrintSimpleResult(editDateUnix);

            Assert.Multiple(() =>
            {
                Assert.True(sendMessage.Ok);

                Assert.IsInstanceOf(typeof(long), editDateUnix);
                Assert.AreEqual(editDateUnix, 0);
                Assert.AreEqual(editDateUnix.ToString(), "0");
            });
        }
        public void TestAppealToTheEmptyNewChatTitle()
        {
            SendMessageResult sendMessage = mTelegramBot.SendMessage(mChatId, "TestAppealToTheEmptyNewChatTitle()");

            var newChatTitle = sendMessage.Result.NewChatTitle;

            ConsoleUtlis.PrintSimpleResult(newChatTitle);

            Assert.Multiple(() =>
            {
                Assert.True(sendMessage.Ok);

                Assert.IsInstanceOf(typeof(string), newChatTitle);
                Assert.IsEmpty(newChatTitle);
                Assert.AreEqual(newChatTitle, string.Empty);
                Assert.AreEqual(newChatTitle.Length, 0);
            });
        }
        public void TestAppealToTheEmptyCaption()
        {
            SendMessageResult sendMessage = mTelegramBot.SendMessage(mChatId, "TestAppealToTheEmptyCaption()");

            var caption = sendMessage.Result.Caption;

            ConsoleUtlis.PrintSimpleResult(caption);

            Assert.Multiple(() =>
            {
                Assert.True(sendMessage.Ok);

                Assert.IsInstanceOf(typeof(string), caption);
                Assert.IsEmpty(caption);
                Assert.AreEqual(caption, string.Empty);
                Assert.AreEqual(caption.Length, 0);
            });
        }
        public void TestAppealToTheEmptyText()
        {
            const float latitude  = 37.0000114f;
            const float longitude = 37.0000076f;

            SendMessageResult sendLocation = mTelegramBot.SendLocation(mChatId, latitude, longitude);

            var text = sendLocation.Result.Text;

            ConsoleUtlis.PrintSimpleResult(text);

            Assert.Multiple(() =>
            {
                Assert.True(sendLocation.Ok);

                Assert.IsInstanceOf(typeof(string), text);
                Assert.IsEmpty(text);
                Assert.IsEmpty(text.ToUpper());
            });
        }