diff --git a/README.md b/README.md
index 583ef7b..099a4a6 100644
--- a/README.md
+++ b/README.md
@@ -306,16 +306,34 @@ test('it works', () => {
 # toHaveStyleRule
 
 The `toHaveStyleRule` matcher is useful to test if a given rule is applied to a component.
-The first argument is the expected property, the second is the expected value (string or RegExp).
+The first argument is the expected property, the second is the expected value which can be a String, RegExp, Jest asymmetric matcher or `undefined`.
 
 ```js
-test('it works', () => {
+const Button = styled.button`
+  color: red;
+  border: 0.05em solid ${props => props.transparent ? 'transparent' : 'black'};
+  cursor: ${props => !props.disabled && 'pointer'};
+  opacity: ${props => props.disabled && '.65'};
+`
+
+test('it applies default styles', () => {
   const tree = renderer.create(<Button />).toJSON()
   expect(tree).toHaveStyleRule('color', 'red')
+  expect(tree).toHaveStyleRule('border', '0.05em solid black')
+  expect(tree).toHaveStyleRule('cursor', 'pointer')
+  expect(tree).toHaveStyleRule('opacity', undefined) // equivalent of the following
+  expect(tree).not.toHaveStyleRule('opacity', expect.any(String))
+})
+
+test('it applies styles according to passed props', () => {
+  const tree = renderer.create(<Button disabled transparent />).toJSON()
+  expect(tree).toHaveStyleRule('border', expect.stringContaining('transparent'))
+  expect(tree).toHaveStyleRule('cursor', undefined)
+  expect(tree).toHaveStyleRule('opacity', '.65')
 })
 ```
 
-The matcher supports a third `options` parameter which makes it possible to search for rules nested within an [At-rule](https://developer.mozilla.org/en/docs/Web/CSS/At-rule) ([media](https://developer.mozilla.org/en-US/docs/Web/CSS/@media)) or to add modifiers to the class selector. This feature is supported in React only, and more options are coming soon.
+The matcher supports an optional third `options` parameter which makes it possible to search for rules nested within an [At-rule](https://developer.mozilla.org/en/docs/Web/CSS/At-rule) ([media](https://developer.mozilla.org/en-US/docs/Web/CSS/@media)) or to add modifiers to the class selector. This feature is supported in React only, and more options are coming soon.
 
 ```js
 const Button = styled.button`
diff --git a/src/index.d.ts b/src/index.d.ts
index ca704b2..67322c6 100644
--- a/src/index.d.ts
+++ b/src/index.d.ts
@@ -1,11 +1,19 @@
+interface AsymmetricMatcher {
+  $$typeof: Symbol;
+  sample?: string | RegExp | object | Array<any>, Function;
+}
+
+type Value = string | RegExp | AsymmetricMatcher | undefined
+
+interface Options {
+  media?: string;
+  modifier?: string;
+  supports?: string;
+}
+
 declare namespace jest {
-  interface Options {
-    media?: string;
-    modifier?: string;
-    supports?: string;
-  }
 
   interface Matchers<R> {
-    toHaveStyleRule(property: string, value: string | RegExp, options?: Options): R;
+    toHaveStyleRule(property: string, value: Value, options?: Options): R;
   }
 }
diff --git a/src/native/toHaveStyleRule.js b/src/native/toHaveStyleRule.js
index e773b8f..73da958 100644
--- a/src/native/toHaveStyleRule.js
+++ b/src/native/toHaveStyleRule.js
@@ -1,10 +1,12 @@
-function toHaveStyleRule(component, name, expected) {
+const { matcherTest, buildReturnMessage } = require('../utils')
+
+function toHaveStyleRule(component, property, expected) {
   const styles = component.props.style.filter(x => x)
 
   /**
    * Convert style name to camel case (so we can compare)
    */
-  const camelCasedName = name.replace(/-(\w)/, (_, match) =>
+  const camelCasedProperty = property.replace(/-(\w)/, (_, match) =>
     match.toUpperCase()
   )
 
@@ -13,37 +15,13 @@ function toHaveStyleRule(component, name, expected) {
    * stylename against this object
    */
   const mergedStyles = styles.reduce((acc, item) => ({ ...acc, ...item }), {})
-  const received = mergedStyles[camelCasedName]
-  const pass = received === expected
+  const received = mergedStyles[camelCasedProperty]
+  const pass = matcherTest(received, expected)
 
-  if (!received) {
-    const error = `${name} isn't in the style rules`
-    return {
-      message: () =>
-        `${this.utils.matcherHint('.toHaveStyleRule')}\n\n` +
-        `Expected ${component.type} to have a style rule:\n` +
-        `  ${this.utils.printExpected(`${name}: ${expected}`)}\n` +
-        'Received:\n' +
-        `  ${this.utils.printReceived(error)}`,
-      pass: false,
-    }
+  return {
+    pass,
+    message: buildReturnMessage(this.utils, pass, property, received, expected),
   }
-
-  const diff =
-    '' +
-    `  ${this.utils.printExpected(`${name}: ${expected}`)}\n` +
-    'Received:\n' +
-    `  ${this.utils.printReceived(`${name}: ${received}`)}`
-
-  const message = pass
-    ? () =>
-        `${this.utils.matcherHint('.not.toHaveStyleRule')}\n\n` +
-        `Expected ${component.type} not to contain:\n${diff}`
-    : () =>
-        `${this.utils.matcherHint('.toHaveStyleRule')}\n\n` +
-        `Expected ${component.type} to have a style rule:\n${diff}`
-
-  return { message, pass }
 }
 
 module.exports = toHaveStyleRule
diff --git a/src/toHaveStyleRule.js b/src/toHaveStyleRule.js
index 382e237..c5df324 100644
--- a/src/toHaveStyleRule.js
+++ b/src/toHaveStyleRule.js
@@ -1,4 +1,4 @@
-const { getCSS } = require('./utils')
+const { getCSS, matcherTest, buildReturnMessage } = require('./utils')
 
 const shouldDive = node =>
   typeof node.dive === 'function' && typeof node.type() !== 'string'
@@ -76,9 +76,14 @@ const getRules = (ast, classNames, options) => {
   )
 }
 
-const die = (utils, property) => ({
+const handleMissingRules = options => ({
   pass: false,
-  message: () => `Property not found: ${utils.printReceived(property)}`,
+  message: () =>
+    `No style rules found on passed Component${
+      Object.keys(options).length
+        ? ` using options:\n${JSON.stringify(options)}`
+        : ''
+    }`,
 })
 
 const getDeclaration = (rule, property) =>
@@ -92,41 +97,31 @@ const getDeclaration = (rule, property) =>
 const getDeclarations = (rules, property) =>
   rules.map(rule => getDeclaration(rule, property)).filter(Boolean)
 
-const normalizeModifierOption = modifier =>
-  Array.isArray(modifier) ? modifier.join('') : modifier
+/* eslint-disable prettier/prettier */
+const normalizeOptions = ({ modifier, ...options }) =>
+  modifier
+    ? Object.assign(options, {
+      modifier: Array.isArray(modifier) ? modifier.join('') : modifier,
+    })
+    : options
+/* eslint-enable prettier/prettier */
 
-function toHaveStyleRule(received, property, value, options = {}) {
-  const classNames = getClassNames(received)
+function toHaveStyleRule(component, property, expected, options = {}) {
   const ast = getCSS()
-  options.modifier = normalizeModifierOption(options.modifier)
-  const rules = getRules(ast, classNames, options)
+  const classNames = getClassNames(component)
+  const normalizedOptions = normalizeOptions(options)
+  const rules = getRules(ast, classNames, normalizedOptions)
 
-  if (!rules.length) {
-    return die(this.utils, property)
-  }
+  if (!rules.length) return handleMissingRules(normalizedOptions)
 
   const declarations = getDeclarations(rules, property)
-
-  if (!declarations.length) {
-    return die(this.utils, property)
-  }
-
-  const declaration = declarations.pop()
-
-  const pass =
-    value instanceof RegExp
-      ? value.test(declaration.value)
-      : value === declaration.value
-
-  const message = () =>
-    `Expected ${property}${pass ? ' not ' : ' '}to match:\n` +
-    `  ${this.utils.printExpected(value)}\n` +
-    'Received:\n' +
-    `  ${this.utils.printReceived(declaration.value)}`
+  const declaration = declarations.pop() || {}
+  const received = declaration.value
+  const pass = matcherTest(received, expected)
 
   return {
     pass,
-    message,
+    message: buildReturnMessage(this.utils, pass, property, received, expected),
   }
 }
 
diff --git a/src/utils.js b/src/utils.js
index 5ecd335..dfe0496 100644
--- a/src/utils.js
+++ b/src/utils.js
@@ -58,8 +58,36 @@ const getHashes = () =>
     .concat(getComponentIDs())
     .filter(Boolean)
 
+const buildReturnMessage = (utils, pass, property, received, expected) => () =>
+  `${utils.printReceived(
+    !received && !pass
+      ? `Property '${property}' not found in style rules`
+      : `Value mismatch for property '${property}'`
+  )}\n\n` +
+  'Expected\n' +
+  `  ${utils.printExpected(`${property}: ${expected}`)}\n` +
+  'Received:\n' +
+  `  ${utils.printReceived(`${property}: ${received}`)}`
+
+const matcherTest = (received, expected) => {
+  try {
+    const matcher =
+      expected === undefined ||
+      expected.$$typeof === Symbol.for('jest.asymmetricMatcher')
+        ? expected
+        : expect.stringMatching(expected)
+
+    expect(received).toEqual(matcher)
+    return true
+  } catch (error) {
+    return false
+  }
+}
+
 module.exports = {
   resetStyleSheet,
   getCSS,
   getHashes,
+  buildReturnMessage,
+  matcherTest,
 }
diff --git a/test/__snapshots__/toHaveStyleRule.spec.js.snap b/test/__snapshots__/toHaveStyleRule.spec.js.snap
index ebb6942..8a7bc63 100644
--- a/test/__snapshots__/toHaveStyleRule.spec.js.snap
+++ b/test/__snapshots__/toHaveStyleRule.spec.js.snap
@@ -1,10 +1,26 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
-exports[`message when property not found 1`] = `"Property not found: \\"a\\""`;
+exports[`message when property not found 1`] = `
+"\\"Property 'background-color' not found in style rules\\"
+
+Expected
+  \\"background-color: black\\"
+Received:
+  \\"background-color: undefined\\""
+`;
+
+exports[`message when rules not found 1`] = `"No style rules found on passed Component"`;
+
+exports[`message when rules not found using options 1`] = `
+"No style rules found on passed Component using options:
+{\\"media\\":\\"(max-width:640px)\\",\\"modifier\\":\\":hover\\"}"
+`;
 
 exports[`message when value does not match 1`] = `
-"Expected background to match:
-  \\"red\\"
+"\\"Value mismatch for property 'background'\\"
+
+Expected
+  \\"background: red\\"
 Received:
-  \\"orange\\""
+  \\"background: orange\\""
 `;
diff --git a/test/native/__snapshots__/toHaveStyleRule.spec.js.snap b/test/native/__snapshots__/toHaveStyleRule.spec.js.snap
index c5d4734..3ad72f0 100644
--- a/test/native/__snapshots__/toHaveStyleRule.spec.js.snap
+++ b/test/native/__snapshots__/toHaveStyleRule.spec.js.snap
@@ -1,10 +1,19 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
+exports[`message when property not found 1`] = `
+"\\"Property 'color' not found in style rules\\"
+
+Expected
+  \\"color: black\\"
+Received:
+  \\"color: undefined\\""
+`;
+
 exports[`message when value does not match 1`] = `
-"expect(received).toHaveStyleRule(expected)
+"\\"Value mismatch for property 'background-color'\\"
 
-Expected View to have a style rule:
-  \\"background: red\\"
+Expected
+  \\"background-color: red\\"
 Received:
-  \\"background isn't in the style rules\\""
+  \\"background-color: orange\\""
 `;
diff --git a/test/native/toHaveStyleRule.spec.js b/test/native/toHaveStyleRule.spec.js
index 910a122..8d55603 100644
--- a/test/native/toHaveStyleRule.spec.js
+++ b/test/native/toHaveStyleRule.spec.js
@@ -13,48 +13,100 @@ test('basic', () => {
   expect(tree).toHaveStyleRule('background-color', 'papayawhip')
 })
 
-xtest('message when property not found', () => {
-  expect(() => expect(null).toHaveStyleRule('a')).toThrowErrorMatchingSnapshot()
-})
+test('message when property not found', () => {
+  const Button = styled.Text`
+    background-color: papayawhip;
+  `
 
-xtest('null', () => {
-  expect(null).not.toHaveStyleRule('a', 'b')
+  expect(() =>
+    expect(renderer.create(<Button />).toJSON()).toHaveStyleRule(
+      'color',
+      'black'
+    )
+  ).toThrowErrorMatchingSnapshot()
 })
 
 test('message when value does not match', () => {
   const StyledView = styled.View`
-    background: orange;
+    background-color: orange;
   `
 
   expect(() => {
     expect(renderer.create(<StyledView />).toJSON()).toHaveStyleRule(
-      'background',
+      'background-color',
       'red'
     )
   }).toThrowErrorMatchingSnapshot()
 })
 
-xtest('basic', () => {
+test('basic', () => {
   const StyledView = styled.View`
     padding: 4px;
-    background: papayawhip;
+    background-color: papayawhip;
   `
 
   expect(renderer.create(<StyledView />).toJSON()).toHaveStyleRule(
-    'background',
+    'background-color',
     'papayawhip'
   )
 })
 
-xtest('regex', () => {
+test('regex', () => {
   const StyledView = styled.View`
     padding: 4px;
-    background: papayawhip;
+    background-color: papayawhip;
   `
 
   expect(renderer.create(<StyledView />).toJSON()).toHaveStyleRule(
-    'background',
-    /^p/
+    'background-color',
+    /^papaya/
+  )
+})
+
+test('undefined', () => {
+  const Button = styled.Text`
+    ${({ transparent }) => !transparent && 'background-color: papayawhip;'};
+  `
+
+  expect(renderer.create(<Button />).toJSON()).toHaveStyleRule(
+    'background-color',
+    'papayawhip'
+  )
+  expect(renderer.create(<Button transparent />).toJSON()).toHaveStyleRule(
+    'background-color',
+    undefined
+  )
+})
+
+test('jest asymmetric matchers', () => {
+  const Button = styled.Text`
+    background-color: ${({ transparent }) =>
+      transparent ? 'transparent' : 'papayawhip'};
+  `
+
+  expect(renderer.create(<Button />).toJSON()).toHaveStyleRule(
+    'background-color',
+    expect.any(String)
+  )
+  expect(renderer.create(<Button />).toJSON()).toHaveStyleRule(
+    'background-color',
+    expect.stringMatching('papayawhip')
+  )
+  expect(renderer.create(<Button />).toJSON()).toHaveStyleRule(
+    'background-color',
+    expect.stringMatching(/^papaya/)
+  )
+  expect(renderer.create(<Button transparent />).toJSON()).toHaveStyleRule(
+    'background-color',
+    expect.stringContaining('transparent')
+  )
+  expect(renderer.create(<Button transparent />).toJSON()).not.toHaveStyleRule(
+    'color',
+    expect.any(String)
+  )
+  expect(renderer.create(<Button transparent />).toJSON()).not.toHaveStyleRule(
+    'color',
+    expect.anything()
   )
 })
 
diff --git a/test/toHaveStyleRule.spec.js b/test/toHaveStyleRule.spec.js
index c8409cb..5e1d3c8 100644
--- a/test/toHaveStyleRule.spec.js
+++ b/test/toHaveStyleRule.spec.js
@@ -23,10 +23,6 @@ const toHaveStyleRule = (component, property, value, options) => {
   expect(mount(component)).toHaveStyleRule(property, value, options)
 }
 
-test('message when property not found', () => {
-  expect(() => expect(null).toHaveStyleRule('a')).toThrowErrorMatchingSnapshot()
-})
-
 test('null', () => {
   expect(null).not.toHaveStyleRule('a', 'b')
 })
@@ -35,6 +31,43 @@ test('non-styled', () => {
   notToHaveStyleRule(<div />, 'a', 'b')
 })
 
+test('message when rules not found', () => {
+  expect(() =>
+    expect(renderer.create(<div />).toJSON()).toHaveStyleRule('color', 'black')
+  ).toThrowErrorMatchingSnapshot()
+})
+
+test('message when rules not found using options', () => {
+  const Button = styled.button`
+    color: red;
+  `
+
+  toHaveStyleRule(<Button />, 'color', 'red')
+  expect(() =>
+    expect(renderer.create(<Button />).toJSON()).toHaveStyleRule(
+      'color',
+      'red',
+      {
+        media: '(max-width:640px)',
+        modifier: ':hover',
+      }
+    )
+  ).toThrowErrorMatchingSnapshot()
+})
+
+test('message when property not found', () => {
+  const Button = styled.button`
+    color: red;
+  `
+
+  expect(() =>
+    expect(renderer.create(<Button />).toJSON()).toHaveStyleRule(
+      'background-color',
+      'black'
+    )
+  ).toThrowErrorMatchingSnapshot()
+})
+
 test('message when value does not match', () => {
   const Wrapper = styled.section`
     background: orange;
@@ -66,6 +99,42 @@ test('regex', () => {
   toHaveStyleRule(<Wrapper />, 'background', /^p/)
 })
 
+test('undefined', () => {
+  const Button = styled.button`
+    cursor: ${({ disabled }) => !disabled && 'pointer'};
+    opacity: ${({ disabled }) => disabled && '.65'};
+  `
+
+  toHaveStyleRule(<Button />, 'opacity', undefined)
+  toHaveStyleRule(<Button />, 'cursor', 'pointer')
+  toHaveStyleRule(<Button disabled />, 'opacity', '.65')
+  toHaveStyleRule(<Button disabled />, 'cursor', undefined)
+})
+
+test('jest asymmetric matchers', () => {
+  const Button = styled.button`
+    border: 0.1em solid
+      ${({ transparent }) => (transparent ? 'transparent' : 'black')};
+  `
+
+  toHaveStyleRule(<Button />, 'border', expect.any(String))
+  toHaveStyleRule(<Button />, 'border', expect.stringMatching('solid'))
+  toHaveStyleRule(<Button />, 'border', expect.stringMatching(/^0.1em/))
+  toHaveStyleRule(<Button />, 'border', expect.stringContaining('black'))
+  notToHaveStyleRule(
+    <Button transparent />,
+    'border',
+    expect.stringContaining('black')
+  )
+  toHaveStyleRule(
+    <Button transparent />,
+    'border',
+    expect.stringContaining('transparent')
+  )
+  notToHaveStyleRule(<Button />, 'color', expect.any(String))
+  notToHaveStyleRule(<Button />, 'color', expect.anything())
+})
+
 test('any component', () => {
   const Link = ({ className, children }) => (
     <a className={className}>{children}</a>