Ações do Mouse

import pytest
from time import sleep
from selenium.webdriver import ActionChains
from selenium.webdriver.common.actions.action_builder import ActionBuilder
from selenium.webdriver.common.actions.mouse_button import MouseButton
from selenium.webdriver.common.by import By
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC


def test_click_and_hold(driver):
    driver.get('https://selenium.dev/selenium/web/mouse_interaction.html')

    clickable = driver.find_element(By.ID, "clickable")
    ActionChains(driver) \
        .click_and_hold(clickable) \
        .perform()

    sleep(0.5)
    assert driver.find_element(By.ID, "click-status").text == "focused"


def test_click_and_release(driver):
    driver.get('https://selenium.dev/selenium/web/mouse_interaction.html')

    clickable = driver.find_element(By.ID, "click")
    ActionChains(driver) \
        .click(clickable) \
        .perform()

    assert "resultPage.html" in driver.current_url


def test_right_click(driver):
    driver.get('https://selenium.dev/selenium/web/mouse_interaction.html')

    clickable = driver.find_element(By.ID, "clickable")
    ActionChains(driver) \
        .context_click(clickable) \
        .perform()

    sleep(0.5)
    assert driver.find_element(By.ID, "click-status").text == "context-clicked"


def test_back_click_ab(driver):
    driver.get('https://selenium.dev/selenium/web/mouse_interaction.html')
    driver.find_element(By.ID, "click").click()
    assert driver.title == "We Arrive Here"

    action = ActionBuilder(driver)
    action.pointer_action.pointer_down(MouseButton.BACK)
    action.pointer_action.pointer_up(MouseButton.BACK)
    action.perform()

    assert driver.title == "BasicMouseInterfaceTest"


def test_forward_click_ab(driver):
    driver.get('https://selenium.dev/selenium/web/mouse_interaction.html')
    driver.find_element(By.ID, "click").click()
    driver.back()
    assert driver.title == "BasicMouseInterfaceTest"

    action = ActionBuilder(driver)
    action.pointer_action.pointer_down(MouseButton.FORWARD)
    action.pointer_action.pointer_up(MouseButton.FORWARD)
    action.perform()

    assert driver.title == "We Arrive Here"


def test_double_click(driver):
    driver.get('https://selenium.dev/selenium/web/mouse_interaction.html')

    clickable = driver.find_element(By.ID, "clickable")
    ActionChains(driver) \
        .double_click(clickable) \
        .perform()

    assert driver.find_element(By.ID, "click-status").text == "double-clicked"


def test_hover(driver):
    driver.get('https://selenium.dev/selenium/web/mouse_interaction.html')

    hoverable = driver.find_element(By.ID, "hover")
    ActionChains(driver) \
        .move_to_element(hoverable) \
        .perform()

    assert driver.find_element(By.ID, "move-status").text == "hovered"


def test_move_by_offset_from_element(driver):
    driver.get('https://selenium.dev/selenium/web/mouse_interaction.html')

    mouse_tracker = driver.find_element(By.ID, "mouse-tracker")
    ActionChains(driver) \
        .move_to_element_with_offset(mouse_tracker, 8, 0) \
        .perform()

    coordinates = driver.find_element(By.ID, "relative-location").text.split(", ")
    assert abs(int(coordinates[0]) - 100 - 8) < 2


def test_move_by_offset_from_viewport_origin_ab(driver):
    driver.get('https://selenium.dev/selenium/web/mouse_interaction.html')
    WebDriverWait(driver, 10).until(EC.presence_of_element_located((By.ID, "absolute-location")))
    action = ActionBuilder(driver)
    action.pointer_action.move_to_location(8, 0)
    action.perform()

    coordinates = driver.find_element(By.ID, "absolute-location").text.split(", ")

    assert abs(int(coordinates[0]) - 8) < 2


def test_move_by_offset_from_current_pointer_ab(driver):
    driver.get('https://selenium.dev/selenium/web/mouse_interaction.html')

    action = ActionBuilder(driver)
    action.pointer_action.move_to_location(6, 3)
    action.perform()

    ActionChains(driver) \
        .move_by_offset(13, 15) \
        .perform()

    coordinates = driver.find_element(By.ID, "absolute-location").text.split(", ")

    assert abs(int(coordinates[0]) - 6 - 13) < 2
    assert abs(int(coordinates[1]) - 3 - 15) < 2


def test_drag_and_drop_onto_element(driver):
    driver.get('https://selenium.dev/selenium/web/mouse_interaction.html')

    draggable = driver.find_element(By.ID, "draggable")
    droppable = driver.find_element(By.ID, "droppable")
    ActionChains(driver) \
        .drag_and_drop(draggable, droppable) \
        .perform()

    assert driver.find_element(By.ID, "drop-status").text == "dropped"


def test_drag_and_drop_by_offset(driver):
    driver.get('https://selenium.dev/selenium/web/mouse_interaction.html')

    draggable = driver.find_element(By.ID, "draggable")
    start = draggable.location
    finish = driver.find_element(By.ID, "droppable").location
    ActionChains(driver) \
        .drag_and_drop_by_offset(draggable, finish['x'] - start['x'], finish['y'] - start['y']) \
        .perform()

    assert driver.find_element(By.ID, "drop-status").text == "dropped"

using System;
using System.Drawing;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using OpenQA.Selenium;
using OpenQA.Selenium.Interactions;

namespace SeleniumDocs.ActionsAPI
{
    [TestClass]
    public class MouseTest : BaseChromeTest
    {
        [TestMethod]
        public void ClickAndHold()
        {
            driver.Url = "https://selenium.dev/selenium/web/mouse_interaction.html";
            
            IWebElement clickable = driver.FindElement(By.Id("clickable"));
            new Actions(driver)
                .ClickAndHold(clickable)
                .Perform();
            
            Assert.AreEqual("focused", driver.FindElement(By.Id("click-status")).Text);
        }
        
        [TestMethod]
        public void ClickAndRelease()
        {
            driver.Url = "https://selenium.dev/selenium/web/mouse_interaction.html";
            
            IWebElement clickable = driver.FindElement(By.Id("click"));
            new Actions(driver)
                .Click(clickable)
                .Perform();
            
            Assert.IsTrue(driver.Url.Contains("resultPage.html"));
        }

        [TestMethod]
        public void RightClick()
        {
            driver.Url = "https://selenium.dev/selenium/web/mouse_interaction.html";
            
            IWebElement clickable = driver.FindElement(By.Id("clickable"));
            new Actions(driver)
                .ContextClick(clickable)
                .Perform();
            
            Assert.AreEqual("context-clicked", driver.FindElement(By.Id("click-status")).Text);
        }
        
        [TestMethod]
        public void BackClick()
        {
            driver.Url = "https://selenium.dev/selenium/web/mouse_interaction.html";

            driver.FindElement(By.Id("click")).Click();
            Assert.AreEqual("We Arrive Here", driver.Title);

            ActionBuilder actionBuilder = new ActionBuilder();
            PointerInputDevice mouse = new PointerInputDevice(PointerKind.Mouse, "default mouse");
            actionBuilder.AddAction(mouse.CreatePointerDown(MouseButton.Back));
            actionBuilder.AddAction(mouse.CreatePointerUp(MouseButton.Back));
            ((IActionExecutor)driver).PerformActions(actionBuilder.ToActionSequenceList());

            Assert.AreEqual("BasicMouseInterfaceTest", driver.Title);
        }

        [TestMethod]
        public void ForwardClick()
        {
            driver.Url = "https://selenium.dev/selenium/web/mouse_interaction.html";

            driver.FindElement(By.Id("click")).Click();
            driver.Navigate().Back();
            Assert.AreEqual("BasicMouseInterfaceTest", driver.Title);

            ActionBuilder actionBuilder = new ActionBuilder();
            PointerInputDevice mouse = new PointerInputDevice(PointerKind.Mouse, "default mouse");
            actionBuilder.AddAction(mouse.CreatePointerDown(MouseButton.Forward));
            actionBuilder.AddAction(mouse.CreatePointerUp(MouseButton.Forward));
            ((IActionExecutor)driver).PerformActions(actionBuilder.ToActionSequenceList());

            Assert.AreEqual("We Arrive Here", driver.Title);
        }

        [TestMethod]
        public void DoubleClick()
        {
            driver.Url = "https://selenium.dev/selenium/web/mouse_interaction.html";
            
            IWebElement clickable = driver.FindElement(By.Id("clickable"));
            new Actions(driver)
                .DoubleClick(clickable)
                .Perform();
            
            Assert.AreEqual("double-clicked", driver.FindElement(By.Id("click-status")).Text);
        }

        [TestMethod]
        public void Hovers()
        {
            driver.Url = "https://selenium.dev/selenium/web/mouse_interaction.html";
            
            IWebElement hoverable = driver.FindElement(By.Id("hover"));
            new Actions(driver)
                .MoveToElement(hoverable)
                .Perform();
            
            Assert.AreEqual("hovered", driver.FindElement(By.Id("move-status")).Text);
        }

        [TestMethod]
        [Obsolete("Obsolete")]
        public void MoveByOffsetFromTopLeftOfElement()
        {
            driver.Url = "https://selenium.dev/selenium/web/mouse_interaction.html";
            
            IWebElement tracker = driver.FindElement(By.Id("mouse-tracker"));
            new Actions(driver)
                .MoveToElement(tracker, 8, 0)
                .Perform();

            string[] result = driver.FindElement(By.Id("relative-location")).Text.Split(", ");
            Assert.IsTrue(Math.Abs(int.Parse(result[0]) - 100 - 8) < 2);
        }

        [TestMethod]
        public void MoveByOffsetFromCenterOfElement()
        {
            driver.Url = "https://selenium.dev/selenium/web/mouse_interaction.html";
            
            IWebElement tracker = driver.FindElement(By.Id("mouse-tracker"));
            new Actions(driver)
                .MoveToElement(tracker, 8, 0)
                .Perform();

            string[] result = driver.FindElement(By.Id("relative-location")).Text.Split(", ");
            Assert.IsTrue(Math.Abs(int.Parse(result[0]) - 100 - 8) < 2);
        }
        
        [TestMethod]
        public void MoveByOffsetFromViewport()
        {
            driver.Url = "https://selenium.dev/selenium/web/mouse_interaction.html";

            ActionBuilder actionBuilder = new ActionBuilder();
            PointerInputDevice mouse = new PointerInputDevice(PointerKind.Mouse, "default mouse");
            actionBuilder.AddAction(mouse.CreatePointerMove(CoordinateOrigin.Viewport,
                8, 0, TimeSpan.Zero));
            ((IActionExecutor)driver).PerformActions(actionBuilder.ToActionSequenceList());
            
            string[] result = driver.FindElement(By.Id("absolute-location")).Text.Split(", ");
            Assert.IsTrue(Math.Abs(int.Parse(result[0]) - 8) < 2);
        }

        [TestMethod]
        public void MoveByOffsetFromCurrentPointerLocation()
        {
            driver.Url = "https://selenium.dev/selenium/web/mouse_interaction.html";

            ActionBuilder actionBuilder = new ActionBuilder();
            PointerInputDevice mouse = new PointerInputDevice(PointerKind.Mouse, "default mouse");
            actionBuilder.AddAction(mouse.CreatePointerMove(CoordinateOrigin.Viewport,
                8, 12, TimeSpan.Zero));
            ((IActionExecutor)driver).PerformActions(actionBuilder.ToActionSequenceList());
            
            new Actions(driver)
                .MoveByOffset(13, 15)
                .Perform();

            string[] result = driver.FindElement(By.Id("absolute-location")).Text.Split(", ");
            Assert.IsTrue(Math.Abs(int.Parse(result[0]) - 8 - 13) < 2);
            Assert.IsTrue(Math.Abs(int.Parse(result[1]) - 12 - 15) < 2);
        }

        [TestMethod]
        public void DragToElement()
        {
            driver.Url = "https://selenium.dev/selenium/web/mouse_interaction.html";
            
            IWebElement draggable = driver.FindElement(By.Id("draggable"));
            IWebElement droppable = driver.FindElement(By.Id("droppable"));
            new Actions(driver)
                .DragAndDrop(draggable, droppable)
                .Perform();
            
            Assert.AreEqual("dropped", driver.FindElement(By.Id("drop-status")).Text);
        }

        [TestMethod]
        public void DragByOffset()
        {
            driver.Url = "https://selenium.dev/selenium/web/mouse_interaction.html";
            
            IWebElement draggable = driver.FindElement(By.Id("draggable"));
            Point start = draggable.Location;
            Point finish = driver.FindElement(By.Id("droppable")).Location;
            new Actions(driver)
                .DragAndDropToOffset(draggable, finish.X - start.X, finish.Y - start.Y)
                .Perform();
            
            Assert.AreEqual("dropped", driver.FindElement(By.Id("drop-status")).Text);
        }
    }
}

# frozen_string_literal: true

require 'spec_helper'

RSpec.describe 'Mouse' do
  let(:driver) { start_session }

  it 'click and hold' do
    driver.get 'https://www.selenium.dev/selenium/web/mouse_interaction.html'

    clickable = driver.find_element(id: 'clickable')
    driver.action
          .click_and_hold(clickable)
          .perform

    expect(driver.find_element(id: 'click-status').text).to eq 'focused'
  end

  it 'click and release' do
    driver.get 'https://www.selenium.dev/selenium/web/mouse_interaction.html'

    clickable = driver.find_element(id: 'click')
    driver.action
          .click(clickable)
          .perform

    expect(driver.current_url).to include 'resultPage.html'
  end

  describe 'alternate button clicks' do
    it 'right click' do
      driver.get 'https://www.selenium.dev/selenium/web/mouse_interaction.html'

      clickable = driver.find_element(id: 'clickable')
      driver.action
            .context_click(clickable)
            .perform

      expect(driver.find_element(id: 'click-status').text).to eq 'context-clicked'
    end

    it 'back click' do
      driver.get 'https://www.selenium.dev/selenium/web/mouse_interaction.html'
      driver.find_element(id: 'click').click
      expect(driver.title).to eq('We Arrive Here')

      driver.action
            .pointer_down(:back)
            .pointer_up(:back)
            .perform

      expect(driver.title).to eq('BasicMouseInterfaceTest')
    end

    it 'forward click' do
      driver.get 'https://www.selenium.dev/selenium/web/mouse_interaction.html'
      driver.find_element(id: 'click').click
      driver.navigate.back
      expect(driver.title).to eq('BasicMouseInterfaceTest')

      driver.action
            .pointer_down(:forward)
            .pointer_up(:forward)
            .perform

      expect(driver.title).to eq('We Arrive Here')
    end
  end

  it 'double click' do
    driver.get 'https://www.selenium.dev/selenium/web/mouse_interaction.html'

    clickable = driver.find_element(id: 'clickable')
    driver.action
          .double_click(clickable)
          .perform

    expect(driver.find_element(id: 'click-status').text).to eq 'double-clicked'
  end

  it 'hovers' do
    driver.get 'https://www.selenium.dev/selenium/web/mouse_interaction.html'

    hoverable = driver.find_element(id: 'hover')
    driver.action
          .move_to(hoverable)
          .perform

    expect(driver.find_element(id: 'move-status').text).to eq 'hovered'
  end

  describe 'move by offset' do
    it 'offset from element' do
      driver.get 'https://www.selenium.dev/selenium/web/mouse_interaction.html'
      driver.action.scroll_to(driver.find_element(id: 'bottom')).perform

      mouse_tracker = driver.find_element(id: 'mouse-tracker')
      driver.action
            .move_to(mouse_tracker, 8, 11)
            .perform

      rect = mouse_tracker.rect
      center_x = rect.width / 2
      center_y = rect.height / 2
      x_coord, y_coord = driver.find_element(id: 'relative-location').text.split(',').map(&:to_i)

      expect(x_coord).to be_within(1).of(center_x + 8)
      expect(y_coord).to be_within(1).of(center_y + 11)
    end

    it 'offset from viewport' do
      driver.get 'https://www.selenium.dev/selenium/web/mouse_interaction.html'

      driver.action
            .move_to_location(8, 12)
            .perform

      x_coord, y_coord = driver.find_element(id: 'absolute-location').text.split(',').map(&:to_i)
      expect(x_coord).to be_within(1).of(8)
      expect(y_coord).to be_within(1).of(12)
    end

    it 'offset from current pointer location' do
      driver.get 'https://www.selenium.dev/selenium/web/mouse_interaction.html'

      driver.action.move_to_location(8, 11).perform

      driver.action
            .move_by(13, 15)
            .perform

      x_coord, y_coord = driver.find_element(id: 'absolute-location').text.split(',').map(&:to_i)
      expect(x_coord).to be_within(1).of(8 + 13)
      expect(y_coord).to be_within(1).of(11 + 15)
    end
  end

  it 'drags to another element' do
    driver.get 'https://www.selenium.dev/selenium/web/mouse_interaction.html'

    draggable = driver.find_element(id: 'draggable')
    droppable = driver.find_element(id: 'droppable')
    driver.action
          .drag_and_drop(draggable, droppable)
          .perform

    expect(driver.find_element(id: 'drop-status').text).to include('dropped')
  end

  it 'drags by an offset' do
    driver.get 'https://www.selenium.dev/selenium/web/mouse_interaction.html'

    draggable = driver.find_element(id: 'draggable')
    start = draggable.rect
    finish = driver.find_element(id: 'droppable').rect
    driver.action
          .drag_and_drop_by(draggable, finish.x - start.x, finish.y - start.y)
          .perform

    expect(driver.find_element(id: 'drop-status').text).to include('dropped')
  end
end

const {By, Builder} = require('selenium-webdriver');

describe('Click and hold', function () {
  let driver;

  before(async function () {
    driver = new Builder().forBrowser('chrome').build();
  });

  after(async () => await driver.quit());

  it('Mouse move and mouseDown on an element', async function () {
    await driver.get('https://www.selenium.dev/selenium/web/mouse_interaction.html');
    let clickable = driver.findElement(By.id("clickable"));
    const actions = driver.actions({async: true});
    await actions.move({origin: clickable}).press().perform();
  });
});

package dev.selenium.actions_api

import dev.selenium.BaseTest
import org.junit.jupiter.api.Assertions
import org.junit.jupiter.api.Test
import org.openqa.selenium.By
import org.openqa.selenium.Rectangle
import org.openqa.selenium.WebElement
import org.openqa.selenium.interactions.Actions
import org.openqa.selenium.interactions.PointerInput
import org.openqa.selenium.interactions.Sequence
import org.openqa.selenium.remote.RemoteWebDriver

import java.time.Duration
import java.util.Collections

class MouseTest : BaseTest() {
        
    @Test
    fun clickAndHold() { 
        driver.get("https://www.selenium.dev/selenium/web/mouse_interaction.html")

        val clickable = driver.findElement(By.id("clickable"))
        Actions(driver)
                .clickAndHold(clickable)
                .perform()

        Assertions.assertEquals("focused", driver.findElement(By.id("click-status")).getText())
    } 

    @Test
    fun clickAndRelease() {
        driver.get("https://www.selenium.dev/selenium/web/mouse_interaction.html")

        val clickable = driver.findElement(By.id("click"))
        Actions(driver)
                .click(clickable)
                .perform()

        Assertions.assertTrue(driver.getCurrentUrl()!!.contains("resultPage.html"))
    }
  
    @Test
    fun rightClick() {
        driver.get("https://www.selenium.dev/selenium/web/mouse_interaction.html")

        val clickable = driver.findElement(By.id("clickable"))
        Actions(driver)
                .contextClick(clickable)
                .perform()

        Assertions.assertEquals("context-clicked", driver.findElement(By.id("click-status")).getText())
    }
      
    @Test
    fun backClick() {
        driver.get("https://www.selenium.dev/selenium/web/mouse_interaction.html")
        driver.findElement(By.id("click")).click()
        Assertions.assertEquals(driver.getTitle(), "We Arrive Here")

        val mouse = PointerInput(PointerInput.Kind.MOUSE, "default mouse")

        val actions = Sequence(mouse, 0)
                .addAction(mouse.createPointerDown(PointerInput.MouseButton.BACK.asArg()))
                .addAction(mouse.createPointerUp(PointerInput.MouseButton.BACK.asArg()))

        (driver as RemoteWebDriver).perform(Collections.singletonList(actions))

        Assertions.assertEquals("BasicMouseInterfaceTest", driver.getTitle())
    }
     
    @Test
    fun forwardClick() {
        driver.get("https://www.selenium.dev/selenium/web/mouse_interaction.html")
        driver.findElement(By.id("click")).click()
        driver.navigate().back()
        Assertions.assertEquals(driver.getTitle(), "BasicMouseInterfaceTest")

        val mouse = PointerInput(PointerInput.Kind.MOUSE, "default mouse")

        val actions = Sequence(mouse, 0)
                .addAction(mouse.createPointerDown(PointerInput.MouseButton.FORWARD.asArg()))
                .addAction(mouse.createPointerUp(PointerInput.MouseButton.FORWARD.asArg()))

        (driver as RemoteWebDriver).perform(Collections.singletonList(actions))

        Assertions.assertEquals("We Arrive Here", driver.getTitle())
    }
 
    @Test
    fun doubleClick() {
        driver.get("https://www.selenium.dev/selenium/web/mouse_interaction.html")

        val clickable = driver.findElement(By.id("clickable"))
        Actions(driver)
                .doubleClick(clickable)
                .perform()

        Assertions.assertEquals("double-clicked", driver.findElement(By.id("click-status")).getText())
    }

    @Test
    fun hovers() {
        driver.get("https://www.selenium.dev/selenium/web/mouse_interaction.html")

        val hoverable = driver.findElement(By.id("hover"))
        Actions(driver)
                .moveToElement(hoverable)
                .perform()

        Assertions.assertEquals("hovered", driver.findElement(By.id("move-status")).getText())
    }

    @Test
    fun moveByOffsetFromElement() {
        driver.get("https://www.selenium.dev/selenium/web/mouse_interaction.html")
        driver.manage().window().fullscreen()

        val tracker = driver.findElement(By.id("mouse-tracker"))
        Actions(driver)
                .moveToElement(tracker, 8, 0)
                .perform()

        val result = driver.findElement(By.id("relative-location")).getText().split(", ")
        Assertions.assertTrue(Math.abs(Integer.parseInt(result[0]) - 100 - 8) < 2)
    }

    @Test
    fun moveByOffsetFromViewport() {
        driver.get("https://www.selenium.dev/selenium/web/mouse_interaction.html")

        val mouse = PointerInput(PointerInput.Kind.MOUSE, "default mouse")

        val actions = Sequence(mouse, 0)
                .addAction(mouse.createPointerMove(Duration.ZERO, PointerInput.Origin.viewport(), 8, 12))

        (driver as RemoteWebDriver).perform(Collections.singletonList(actions))

        val result = driver.findElement(By.id("absolute-location")).getText().split(", ")
        Assertions.assertTrue(Math.abs(Integer.parseInt(result[0]) - 8) < 2)
        Assertions.assertTrue(Math.abs(Integer.parseInt(result[1]) - 12) < 2)
    }

    @Test
    fun moveByOffsetFromCurrentPointer() {
        driver.get("https://www.selenium.dev/selenium/web/mouse_interaction.html")

        val mouse = PointerInput(PointerInput.Kind.MOUSE, "default mouse")

        val actions = Sequence(mouse, 0)
                .addAction(mouse.createPointerMove(Duration.ZERO, PointerInput.Origin.viewport(), 8, 11))
        (driver as RemoteWebDriver).perform(Collections.singletonList(actions))

        Actions(driver)
                .moveByOffset(13, 15)
                .perform()

        val result = driver.findElement(By.id("absolute-location")).getText().split(", ") 
        Assertions.assertTrue(Math.abs(Integer.parseInt(result[0]) - 8 - 13) < 2)
        Assertions.assertTrue(Math.abs(Integer.parseInt(result[1]) - 11 - 15) < 2)
    }
    
    @Test
    fun dragsToElement() {
        driver.get("https://www.selenium.dev/selenium/web/mouse_interaction.html")

        val draggable = driver.findElement(By.id("draggable"))
        val droppable = driver.findElement(By.id("droppable"))
        Actions(driver)
                .dragAndDrop(draggable, droppable)
                .perform()

        Assertions.assertEquals("dropped", driver.findElement(By.id("drop-status")).getText())
    }
        
    @Test
    fun dragsByOffset() { 
        driver.get("https://www.selenium.dev/selenium/web/mouse_interaction.html")

        val draggable = driver.findElement(By.id("draggable"))
        val start = draggable.getRect()
        val finish = driver.findElement(By.id("droppable")).getRect()
        Actions(driver)
                .dragAndDropBy(draggable, finish.getX() - start.getX(), finish.getY() - start.getY())
                .perform()

        Assertions.assertEquals("dropped", driver.findElement(By.id("drop-status")).getText())
    }
}