public void TestStaticRoomsRoomLinkAsyncCallback()
        {
            var roomId = RoomList != null && RoomList.Any() ? RoomList.First() : Room;

            TestStaticGetRoomLinkAsyncCallback(
                roomId,
                (roomId, link) =>
            {
                var linkExists = link.Public ||
                                 link.Url != null ||
                                 !string.IsNullOrEmpty(link.Description);

                if (linkExists)
                {
                    TestStaticPutRoomLinkAsyncCallback(
                        roomId,
                        roomId =>
                    {
                        TestStaticDeleteRoomLinkAsyncCallback(
                            roomId,
                            roomId =>
                        {
                            TestStaticPostRoomLinkAsyncCallback(roomId, null);
                        });
                    });
                }
                else
                {
                    TestStaticPostRoomLinkAsyncCallback(
                        roomId,
                        roomId =>
                    {
                        TestStaticPutRoomLinkAsyncCallback(
                            roomId,
                            roomId =>
                        {
                            TestStaticDeleteRoomLinkAsyncCallback(roomId, null);
                        });
                    });
                }
            });

            // [GET] /rooms/{room_id}/link.
            void TestStaticGetRoomLinkAsyncCallback(long roomId, Action <long, LinkData> next)
            {
                ChatworkClient.GetRoomLinkAsync(
                    Token,
                    response =>
                {
                    AssertGetRoomLinkResponse(response);

                    if (next != null)
                    {
                        next.Invoke(roomId, response.Data);
                    }
                },
                    roomId);
            }

            // [POST] /rooms/{room_id}/link.
            void TestStaticPostRoomLinkAsyncCallback(long roomId, Action <long> next)
            {
                ChatworkClient.PostRoomLinkAsync(
                    Token,
                    response =>
                {
                    AssertPostRoomLinkResponse(response);

                    if (next != null)
                    {
                        next.Invoke(roomId);
                    }
                },
                    roomId,
                    newLinkParameters);
            }

            // [PUT] /rooms/{room_id}/link.
            void TestStaticPutRoomLinkAsyncCallback(long roomId, Action <long> next)
            {
                ChatworkClient.PutRoomLinkAsync(
                    Token,
                    response =>
                {
                    AssertPutRoomLinkResponse(response);

                    if (next != null)
                    {
                        next.Invoke(roomId);
                    }
                },
                    roomId,
                    updateLinkParameters);
            }

            // [DELETE] /rooms/{room_id}/link.
            void TestStaticDeleteRoomLinkAsyncCallback(long roomId, Action <long> next)
            {
                ChatworkClient.DeleteRoomLinkAsync(
                    Token,
                    response =>
                {
                    AssertDeleteRoomLinkResponse(response);

                    if (next != null)
                    {
                        next.Invoke(roomId);
                    }
                },
                    roomId);
            }
        }
        public async void TestStaticRoomsRoomLinkAsync()
        {
            var roomId = RoomList != null && RoomList.Any() ? RoomList.First() : Room;

            var link = await TestStaticGetRoomLinkAsync(roomId)
                       .ConfigureAwait(false);

            var linkExists = link.Public ||
                             link.Url != null ||
                             !string.IsNullOrEmpty(link.Description);

            if (linkExists)
            {
                await TestStaticPutRoomLinkAsync(roomId)
                .ConfigureAwait(false);

                await TestStaticDeleteRoomLinkAsync(roomId)
                .ConfigureAwait(false);

                await TestStaticPostRoomLinkAsync(roomId)
                .ConfigureAwait(false);
            }
            else
            {
                await TestStaticPostRoomLinkAsync(roomId)
                .ConfigureAwait(false);

                await TestStaticPutRoomLinkAsync(roomId)
                .ConfigureAwait(false);

                await TestStaticDeleteRoomLinkAsync(roomId)
                .ConfigureAwait(false);
            }

            // [GET] /rooms/{room_id}/link.
            async Task <LinkData> TestStaticGetRoomLinkAsync(long roomId)
            {
                var response = await ChatworkClient.GetRoomLinkAsync(Token, roomId)
                               .ConfigureAwait(false);

                AssertGetRoomLinkResponse(response);
                return(response.Data);
            }

            // [POST] /rooms/{room_id}/link.
            async Task TestStaticPostRoomLinkAsync(long roomId)
            {
                var response = await ChatworkClient.PostRoomLinkAsync(Token, roomId, newLinkParameters)
                               .ConfigureAwait(false);

                AssertPostRoomLinkResponse(response);
            }

            // [PUT] /rooms/{room_id}/link.
            async Task TestStaticPutRoomLinkAsync(long roomId)
            {
                var response = await ChatworkClient.PutRoomLinkAsync(Token, roomId, updateLinkParameters)
                               .ConfigureAwait(false);

                AssertPutRoomLinkResponse(response);
            }

            // [DELETE] /rooms/{room_id}/link.
            async Task TestStaticDeleteRoomLinkAsync(long roomId)
            {
                var response = await ChatworkClient.DeleteRoomLinkAsync(Token, roomId)
                               .ConfigureAwait(false);

                AssertDeleteRoomLinkResponse(response);
            }
        }