diff --git a/src/dom-wrapper.ts b/src/dom-wrapper.ts
index 5532604f0..e410eb240 100644
--- a/src/dom-wrapper.ts
+++ b/src/dom-wrapper.ts
@@ -56,13 +56,14 @@ export class DOMWrapper<ElementType extends Element> implements WrapperAPI {
     )
   }
 
-  async setChecked(checked: boolean = true) {
+  private async setChecked(checked: boolean = true) {
     // typecast so we get typesafety
     const element = (this.element as unknown) as HTMLInputElement
+    const type = this.attributes().type
 
-    if (element.tagName !== 'INPUT') {
+    if (type === 'radio' && !checked) {
       throw Error(
-        `You need to call setChecked on an input element. You called it on a ${this.element.tagName}`
+        `wrapper.setChecked() cannot be called with parameter false on a '<input type="radio" /> element.`
       )
     }
 
@@ -78,6 +79,52 @@ export class DOMWrapper<ElementType extends Element> implements WrapperAPI {
     return this.trigger('change')
   }
 
+  setValue(value?: any) {
+    const element = (this.element as unknown) as HTMLInputElement
+    const tagName = element.tagName
+    const type = this.attributes().type
+
+    if (tagName === 'OPTION') {
+      return this.setSelected()
+    } else if (tagName === 'INPUT' && type === 'checkbox') {
+      return this.setChecked(value)
+    } else if (tagName === 'INPUT' && type === 'radio') {
+      return this.setChecked(value)
+    } else if (
+      tagName === 'INPUT' ||
+      tagName === 'TEXTAREA' ||
+      tagName === 'SELECT'
+    ) {
+      element.value = value
+
+      if (tagName === 'SELECT') {
+        return this.trigger('change')
+      }
+      this.trigger('input')
+      // trigger `change` for `v-model.lazy`
+      return this.trigger('change')
+    } else {
+      throw Error(`wrapper.setValue() cannot be called on ${tagName}`)
+    }
+  }
+
+  private setSelected() {
+    const element = (this.element as unknown) as HTMLOptionElement
+
+    if (element.selected) {
+      return
+    }
+
+    element.selected = true
+    let parentElement = element.parentElement
+
+    if (parentElement.tagName === 'OPTGROUP') {
+      parentElement = parentElement.parentElement
+    }
+
+    return new DOMWrapper(parentElement).trigger('change')
+  }
+
   async trigger(eventString: string) {
     const evt = document.createEvent('Event')
     evt.initEvent(eventString)
diff --git a/src/error-wrapper.ts b/src/error-wrapper.ts
index bb942e9a4..44cc75781 100644
--- a/src/error-wrapper.ts
+++ b/src/error-wrapper.ts
@@ -14,6 +14,10 @@ export class ErrorWrapper {
     return Error(`Cannot call ${method} on an empty wrapper.`)
   }
 
+  attributes() {
+    throw this.wrapperError('attributes')
+  }
+
   classes() {
     throw this.wrapperError('classes')
   }
@@ -34,6 +38,10 @@ export class ErrorWrapper {
     throw this.wrapperError('setChecked')
   }
 
+  setValue() {
+    throw this.wrapperError('setValue')
+  }
+
   text() {
     throw this.wrapperError('text')
   }
diff --git a/src/vue-wrapper.ts b/src/vue-wrapper.ts
index 172be7f64..aaefa78c2 100644
--- a/src/vue-wrapper.ts
+++ b/src/vue-wrapper.ts
@@ -76,10 +76,6 @@ export class VueWrapper implements WrapperAPI {
     return Array.from(results).map((x) => new DOMWrapper(x))
   }
 
-  async setChecked(checked: boolean = true) {
-    return new DOMWrapper(this.element).setChecked(checked)
-  }
-
   trigger(eventString: string) {
     const rootElementWrapper = new DOMWrapper(this.element)
     return rootElementWrapper.trigger(eventString)
diff --git a/tests/components/ComponentWithInput.vue b/tests/components/ComponentWithInput.vue
index eb67cf1ce..832263dd6 100644
--- a/tests/components/ComponentWithInput.vue
+++ b/tests/components/ComponentWithInput.vue
@@ -14,6 +14,7 @@
       value="radioBarResult"
     />
     <input type="text" v-model="textVal" />
+    <input id="lazy" type="text" v-model.lazy="lazy" />
     <textarea v-model="textareaVal"></textarea>
     <select v-model="selectVal">
       <option value="selectA"></option>
@@ -36,6 +37,7 @@
     {{ textVal }}
     {{ selectVal }}
     {{ radioVal }}
+    {{ lazy }}
   </div>
 </template>
 
@@ -49,6 +51,7 @@ export default defineComponent({
     return {
       checkboxVal: undefined,
       textVal: undefined,
+      lazy: undefined,
       textareaVal: undefined,
       radioVal: undefined,
       selectVal: undefined,
diff --git a/tests/setChecked.spec.ts b/tests/setChecked.spec.ts
deleted file mode 100644
index 4146820ea..000000000
--- a/tests/setChecked.spec.ts
+++ /dev/null
@@ -1,105 +0,0 @@
-import { defineComponent, h } from 'vue'
-
-import { mount } from '../src'
-import ComponentWithInput from './components/ComponentWithInput.vue'
-
-describe('setChecked', () => {
-  it('works on the root element', async () => {
-    const Comp = defineComponent({
-      render() {
-        return h('input', { type: 'checkbox' })
-      }
-    })
-    const wrapper = mount(Comp)
-    await wrapper.setChecked()
-
-    expect(wrapper.componentVM.$el.checked).toBe(true)
-  })
-
-  it('sets element checked true with no option passed', async () => {
-    const wrapper = mount(ComponentWithInput)
-    const input = wrapper.find<HTMLInputElement>('input[type="checkbox"]')
-    await input.setChecked()
-
-    expect(input.element.checked).toBe(true)
-  })
-
-  it('sets element checked equal to param passed', async () => {
-    const wrapper = mount(ComponentWithInput)
-    const input = wrapper.find<HTMLInputElement>('input[type="checkbox"]')
-
-    await input.setChecked(true)
-    expect(input.element.checked).toBe(true)
-
-    await input.setChecked(false)
-    expect(input.element.checked).toBe(false)
-  })
-
-  it('updates dom with checkbox v-model', async () => {
-    const wrapper = mount(ComponentWithInput)
-    const input = wrapper.find<HTMLInputElement>('input[type="checkbox"]')
-
-    await input.setChecked()
-    expect(wrapper.text()).toContain('checkbox checked')
-
-    await input.setChecked(false)
-    expect(wrapper.text()).not.toContain('checkbox checked')
-  })
-
-  it('changes state the right amount of times with checkbox v-model', async () => {
-    const wrapper = mount(ComponentWithInput)
-    const input = wrapper.find<HTMLInputElement>('input[type="checkbox"]')
-
-    await input.setChecked()
-    await input.setChecked(false)
-    await input.setChecked(false)
-    await input.setChecked(true)
-    await input.setChecked(false)
-    await input.setChecked(false)
-
-    expect(wrapper.find<HTMLInputElement>('.counter').text()).toBe('4')
-  })
-
-  it('does not trigger a change event if the checkbox is already checked', async () => {
-    const listener = jest.fn()
-    const Comp = defineComponent({
-      setup() {
-        return () =>
-          h('input', {
-            onChange: listener,
-            type: 'checkbox',
-            checked: true
-          })
-      }
-    })
-
-    await mount(Comp).setChecked()
-
-    expect(listener).not.toHaveBeenCalled()
-  })
-
-  it('updates dom with radio v-model', async () => {
-    const wrapper = mount(ComponentWithInput)
-
-    await wrapper.find<HTMLInputElement>('#radioBar').setChecked()
-    expect(wrapper.text()).toContain('radioBarResult')
-
-    await wrapper.find<HTMLInputElement>('#radioFoo').setChecked()
-    expect(wrapper.text()).toContain('radioFooResult')
-  })
-
-  it('changes state the right amount of times with radio v-model', async () => {
-    const wrapper = mount(ComponentWithInput)
-    const radioBar = wrapper.find<HTMLInputElement>('#radioBar')
-    const radioFoo = wrapper.find<HTMLInputElement>('#radioFoo')
-
-    await radioBar.setChecked()
-    await radioBar.setChecked()
-    await radioFoo.setChecked()
-    await radioBar.setChecked()
-    await radioBar.setChecked()
-    await radioFoo.setChecked()
-    await radioFoo.setChecked()
-    expect(wrapper.find<HTMLInputElement>('.counter').text()).toBe('4')
-  })
-})
diff --git a/tests/setValue.spec.ts b/tests/setValue.spec.ts
new file mode 100644
index 000000000..119f23952
--- /dev/null
+++ b/tests/setValue.spec.ts
@@ -0,0 +1,180 @@
+import { defineComponent, h, ref } from 'vue'
+import { mount } from '../src'
+import ComponentWithInput from './components/ComponentWithInput.vue'
+
+describe('setValue', () => {
+  describe('on input and textarea', () => {
+    it('sets element of input value', async () => {
+      const wrapper = mount(ComponentWithInput)
+      const input = wrapper.find<HTMLInputElement>('input[type="text"]')
+      await input.setValue('foo')
+
+      expect(wrapper.text()).toContain('foo')
+
+      expect(input.element.value).toBe('foo')
+    })
+
+    it('sets element of textarea value', async () => {
+      const wrapper = mount(ComponentWithInput)
+      const textarea = wrapper.find<HTMLTextAreaElement>('textarea')
+      await textarea.setValue('foo')
+
+      expect(textarea.element.value).toBe('foo')
+    })
+
+    it('updates dom with input v-model.lazy', async () => {
+      const wrapper = mount(ComponentWithInput)
+      const input = wrapper.find<HTMLInputElement>('input#lazy')
+      await input.setValue('lazy')
+
+      expect(wrapper.text()).toContain('lazy')
+    })
+  })
+
+  describe('on select and option', () => {
+    it('sets element of select value', async () => {
+      const wrapper = mount(ComponentWithInput)
+      const select = wrapper.find<HTMLSelectElement>('select')
+      await select.setValue('selectB')
+
+      expect(select.element.value).toEqual('selectB')
+      expect(wrapper.text()).toContain('selectB')
+    })
+
+    it('as an option of a select as selected', async () => {
+      const wrapper = mount(ComponentWithInput)
+      const input = wrapper.find<HTMLOptionElement>('option')
+
+      await input.setValue()
+      expect(wrapper.text()).toContain('selectA')
+    })
+
+    it('sets select with an option group', async () => {
+      const wrapper = mount(ComponentWithInput)
+      const options = wrapper.find('select.with-optgroups').findAll('option')
+      await options[1].setSelected()
+      expect(wrapper.text()).toContain('selectB')
+
+      await options[0].setSelected()
+      expect(wrapper.text()).toContain('selectA')
+    })
+
+    it('does not select an already selected element', async () => {
+      const handle = jest.fn()
+
+      const Component = {
+        setup() {
+          return () =>
+            h('select', { onChange: handle }, [
+              h('option', { value: 'A' }),
+              h('option', { value: 'B' })
+            ])
+        }
+      }
+
+      const wrapper = mount(Component)
+      const input = wrapper.findAll<HTMLOptionElement>('option')[1]
+
+      await input.setValue()
+      await input.setValue()
+      await input.setValue()
+
+      expect(handle).toHaveBeenCalledTimes(1)
+    })
+  })
+
+  describe('on radio and checkbox', () => {
+    it('selects a checkbox by passing a value', async () => {
+      const wrapper = mount(ComponentWithInput)
+      const checkbox = wrapper.find<HTMLInputElement>('input[type=checkbox]')
+      await checkbox.setValue(true)
+
+      expect(wrapper.find('.checkboxResult').exists()).toBe(true)
+      expect(checkbox.element.checked).toBe(true)
+
+      await checkbox.setValue(false)
+
+      expect(wrapper.find('.checkboxResult').exists()).toBe(false)
+      expect(checkbox.element.checked).toBe(false)
+    })
+
+    it('selects a checkbox without passing any value', async () => {
+      const wrapper = mount(ComponentWithInput)
+      await wrapper.find<HTMLInputElement>('input[type=checkbox]').setValue()
+      expect(wrapper.find('.checkboxResult').exists()).toBe(true)
+    })
+
+    it('changes state the right amount of times with checkbox v-model', async () => {
+      const wrapper = mount(ComponentWithInput)
+      const input = wrapper.find<HTMLInputElement>('input[type="checkbox"]')
+
+      await input.setValue()
+      await input.setValue(false)
+      await input.setValue(false)
+      await input.setValue(true)
+      await input.setValue(false)
+      await input.setValue(false)
+
+      expect(wrapper.find<HTMLInputElement>('.counter').text()).toBe('4')
+    })
+
+    it('does not trigger a change event if the checkbox is already checked', async () => {
+      const listener = jest.fn()
+      const Comp = defineComponent({
+        setup() {
+          return () =>
+            h('input', {
+              onChange: listener,
+              type: 'checkbox',
+              checked: true
+            })
+        }
+      })
+
+      await mount(Comp).find('input').setValue()
+
+      expect(listener).not.toHaveBeenCalled()
+    })
+
+    it('selects radio', async () => {
+      const wrapper = mount(ComponentWithInput)
+      const radio = wrapper.find<HTMLInputElement>('#radioBar')
+      await radio.setValue()
+      expect(wrapper.text()).toContain('radioBarResult')
+      expect(radio.element.checked).toBe(true)
+    })
+
+    it('changes state the right amount of times with radio v-model', async () => {
+      const wrapper = mount(ComponentWithInput)
+      const radioBar = wrapper.find<HTMLInputElement>('#radioBar')
+      const radioFoo = wrapper.find<HTMLInputElement>('#radioFoo')
+
+      await radioBar.setValue()
+      await radioBar.setValue()
+      await radioFoo.setValue()
+      await radioBar.setValue()
+      await radioBar.setValue()
+      await radioFoo.setValue()
+      await radioFoo.setValue()
+      expect(wrapper.find<HTMLInputElement>('.counter').text()).toBe('4')
+    })
+
+    it('throws error if element is radio and checked is false', async () => {
+      const message = `wrapper.setChecked() cannot be called with parameter false on a '<input type="radio" /> element`
+      const wrapper = mount(ComponentWithInput)
+      const radioFoo = wrapper.find<HTMLInputElement>('#radioFoo')
+
+      const fn = radioFoo.setValue(false)
+      await expect(fn).rejects.toThrowError(message)
+    })
+  })
+
+  it('throws error if element is not valid', () => {
+    const message = 'wrapper.setValue() cannot be called on LABEL'
+    const wrapper = mount(ComponentWithInput)
+    const input = wrapper.find('#label-el')
+
+    const fn = () => input.setValue('')
+    expect(fn).toThrowError(message)
+  })
+})