diff --git a/.changeset/ten-lines-fail.md b/.changeset/ten-lines-fail.md
new file mode 100644
index 000000000..7ba93232a
--- /dev/null
+++ b/.changeset/ten-lines-fail.md
@@ -0,0 +1,5 @@
+---
+'eslint-plugin-vue': minor
+---
+
+Added new [`vue/no-duplicate-class-names`](https://eslint.vuejs.org/rules/no-duplicate-class-names.html) rule
diff --git a/docs/rules/index.md b/docs/rules/index.md
index 26542db38..3209c157d 100644
--- a/docs/rules/index.md
+++ b/docs/rules/index.md
@@ -234,6 +234,7 @@ For example:
 | [vue/no-bare-strings-in-template] | disallow the use of bare strings in `<template>` |  | :hammer: |
 | [vue/no-boolean-default] | disallow boolean defaults |  | :hammer: |
 | [vue/no-duplicate-attr-inheritance] | enforce `inheritAttrs` to be set to `false` when using `v-bind="$attrs"` |  | :hammer: |
+| [vue/no-duplicate-class-names] | disallow duplication of class names in class attributes | :wrench: | :hammer: |
 | [vue/no-empty-component-block] | disallow the `<template>` `<script>` `<style>` block to be empty | :wrench: | :hammer: |
 | [vue/no-import-compiler-macros] | disallow importing Vue compiler macros | :wrench: | :warning: |
 | [vue/no-multiple-objects-in-class] | disallow passing multiple objects in an array to class |  | :hammer: |
@@ -468,6 +469,7 @@ The following rules extend the rules provided by ESLint itself and apply them to
 [vue/no-dupe-v-else-if]: ./no-dupe-v-else-if.md
 [vue/no-duplicate-attr-inheritance]: ./no-duplicate-attr-inheritance.md
 [vue/no-duplicate-attributes]: ./no-duplicate-attributes.md
+[vue/no-duplicate-class-names]: ./no-duplicate-class-names.md
 [vue/no-empty-component-block]: ./no-empty-component-block.md
 [vue/no-empty-pattern]: ./no-empty-pattern.md
 [vue/no-export-in-script-setup]: ./no-export-in-script-setup.md
diff --git a/docs/rules/no-duplicate-class-names.md b/docs/rules/no-duplicate-class-names.md
new file mode 100644
index 000000000..4c9f5e2e4
--- /dev/null
+++ b/docs/rules/no-duplicate-class-names.md
@@ -0,0 +1,57 @@
+---
+pageClass: rule-details
+sidebarDepth: 0
+title: vue/no-duplicate-class-names
+description: disallow duplication of class names in class attributes
+---
+
+# vue/no-duplicate-class-names
+
+> disallow duplication of class names in class attributes
+
+- :exclamation: <badge text="This rule has not been released yet." vertical="middle" type="error"> _**This rule has not been released yet.**_ </badge>
+- :wrench: The `--fix` option on the [command line](https://eslint.org/docs/user-guide/command-line-interface#fix-problems) can automatically fix some of the problems reported by this rule.
+
+## :book: Rule Details
+
+This rule prevents the same class name from appearing multiple times within the same class attribute or directive.
+
+<eslint-code-block fix :rules="{'vue/no-duplicate-class-names': ['error']}">
+
+```vue
+<template>
+  <!-- ✓ GOOD -->
+  <div class="foo bar"></div>
+  <div :class="'foo bar'"></div>
+  <div :class="{ 'foo bar': isActive }"></div>
+  <div :class="['foo', 'bar']"></div>
+  <div :class="isActive ? 'foo' : 'bar'"></div>
+  <div :class="'foo ' + 'bar'"></div>
+  
+  <!-- ✗ BAD -->
+  <div class="foo foo"></div>
+  <div class="foo bar foo baz bar"></div>
+  <div :class="'foo foo'"></div>
+  <div :class="`foo foo`"></div>
+  <div :class="{ 'foo foo': isActive }"></div>
+  <div :class="['foo foo']"></div>
+  <div :class="['foo foo', { 'bar bar baz': isActive }]"></div>
+  <div :class="isActive ? 'foo foo' : 'bar'"></div>
+  <div :class="'foo foo ' + 'bar'"></div>
+  <div class="foo" :class="'foo'"></div>
+  <div :class="['foo', 'foo']"></div>
+  <div :class="'foo ' + 'foo'"></div>
+  <div :class="['foo', { 'foo': isActive }]"></div>
+</template>
+```
+
+</eslint-code-block>
+
+## :wrench: Options
+
+Nothing.
+
+## :mag: Implementation
+
+- [Rule source](https://github.com/vuejs/eslint-plugin-vue/blob/master/lib/rules/no-duplicate-class-names.js)
+- [Test source](https://github.com/vuejs/eslint-plugin-vue/blob/master/tests/lib/rules/no-duplicate-class-names.js)
diff --git a/lib/index.js b/lib/index.js
index 9b006f9f9..2921a2c99 100644
--- a/lib/index.js
+++ b/lib/index.js
@@ -125,6 +125,7 @@ const plugin = {
     'no-dupe-v-else-if': require('./rules/no-dupe-v-else-if'),
     'no-duplicate-attr-inheritance': require('./rules/no-duplicate-attr-inheritance'),
     'no-duplicate-attributes': require('./rules/no-duplicate-attributes'),
+    'no-duplicate-class-names': require('./rules/no-duplicate-class-names'),
     'no-empty-component-block': require('./rules/no-empty-component-block'),
     'no-empty-pattern': require('./rules/no-empty-pattern'),
     'no-export-in-script-setup': require('./rules/no-export-in-script-setup'),
diff --git a/lib/rules/no-duplicate-class-names.js b/lib/rules/no-duplicate-class-names.js
new file mode 100644
index 000000000..9de76d136
--- /dev/null
+++ b/lib/rules/no-duplicate-class-names.js
@@ -0,0 +1,314 @@
+/**
+ * @fileoverview disallow duplication of class names in class attributes
+ * @author Yizack Rangel
+ * See LICENSE file in root directory for full license.
+ */
+'use strict'
+
+const utils = require('../utils')
+
+/**
+ * @param {VDirective} node
+ * @param {Expression} [expression]
+ * @param {boolean} [unconditional=true] whether the expression is unconditional
+ * @return {IterableIterator<{ node: Literal | TemplateElement, unconditional: boolean }>}
+ */
+function* extractClassNodes(node, expression, unconditional = true) {
+  const nodeExpression = expression ?? node.value?.expression
+  if (!nodeExpression) return
+
+  switch (nodeExpression.type) {
+    case 'Literal': {
+      yield { node: nodeExpression, unconditional }
+      break
+    }
+    case 'ObjectExpression': {
+      for (const prop of nodeExpression.properties) {
+        if (
+          prop.type === 'Property' &&
+          prop.key?.type === 'Literal' &&
+          typeof prop.key.value === 'string'
+        ) {
+          yield { node: prop.key, unconditional: false }
+        }
+      }
+      break
+    }
+    case 'ArrayExpression': {
+      for (const element of nodeExpression.elements) {
+        if (!element || element.type === 'SpreadElement') continue
+        yield* extractClassNodes(node, element, unconditional)
+      }
+      break
+    }
+    case 'ConditionalExpression': {
+      yield* extractClassNodes(node, nodeExpression.consequent, false)
+      yield* extractClassNodes(node, nodeExpression.alternate, false)
+      break
+    }
+    case 'TemplateLiteral': {
+      for (const quasi of nodeExpression.quasis) {
+        yield { node: quasi, unconditional }
+      }
+      for (const expr of nodeExpression.expressions) {
+        yield* extractClassNodes(node, expr, unconditional)
+      }
+      break
+    }
+    case 'BinaryExpression': {
+      if (nodeExpression.operator === '+') {
+        yield* extractClassNodes(node, nodeExpression.left, unconditional)
+        yield* extractClassNodes(node, nodeExpression.right, unconditional)
+      }
+      break
+    }
+  }
+}
+
+/**
+ * @param {string} classList
+ * @returns {string[]}
+ */
+function getClassNames(classList) {
+  return classList.split(/\s+/).filter(Boolean)
+}
+
+/**
+ * @param {string} raw - raw class names string including quotes
+ * @returns {string}
+ */
+function removeDuplicateClassNames(raw) {
+  const quote = raw[0]
+  const inner = raw.slice(1, -1)
+  const tokens = inner.split(/(\s+)/)
+
+  /** @type {string[]} */
+  const kept = []
+  const used = new Set()
+
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i]
+    if (!token) continue
+
+    const isWhitespace = /^\s+$/.test(token)
+
+    if (isWhitespace) {
+      // add whitespace to the last kept item or as leading whitespace
+      if (kept.length > 0) {
+        kept[kept.length - 1] += token
+      } else {
+        kept.push(token)
+      }
+    } else if (used.has(token)) {
+      // handle duplicate class name
+      const nextToken = tokens[i + 1]
+      const hasNextWhitespace =
+        kept.length > 0 && i + 1 < tokens.length && /^\s+$/.test(nextToken)
+
+      if (hasNextWhitespace) {
+        // update spaces of the last non-whitespace item
+        for (let j = kept.length - 1; j >= 0; j--) {
+          const isNotWhitespace = !/^\s+$/.test(kept[j])
+          if (isNotWhitespace) {
+            const parts = kept[j].split(/(\s+)/)
+            kept[j] = parts[0] + nextToken
+            break
+          }
+        }
+        i++ // skip the whitespace token
+      }
+    } else {
+      kept.push(token)
+      used.add(token)
+    }
+  }
+
+  // remove trailing whitespace from the last item if it's not purely whitespace
+  // unless the original string ended with whitespace
+  const endsWithSpace = /\s$/.test(inner)
+  if (kept.length > 0 && !endsWithSpace) {
+    const lastItem = kept[kept.length - 1]
+    const isLastWhitespace = /^\s+$/.test(lastItem)
+    if (!isLastWhitespace) {
+      const parts = lastItem.split(/(\s+)/)
+      kept[kept.length - 1] = parts[0]
+    }
+  }
+
+  return quote + kept.join('') + quote
+}
+
+/** @param {VLiteral | Literal | TemplateElement | null} node */
+function getRawValue(node) {
+  if (!node?.value) return null
+  return typeof node.value === 'object' && 'raw' in node.value
+    ? node.value.raw
+    : node.value
+}
+
+module.exports = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      url: 'https://eslint.vuejs.org/rules/no-duplicate-class-names.html',
+      description: 'disallow duplication of class names in class attributes',
+      categories: undefined
+    },
+    fixable: 'code',
+    schema: [],
+    messages: {
+      duplicateClassName: "Duplicate class name '{{name}}'."
+    }
+  },
+  /** @param {RuleContext} context */
+  create: (context) => {
+    /**
+     * @param {VLiteral | Literal | TemplateElement | null} node
+     */
+    function reportDuplicateClasses(node) {
+      if (!node?.value) return
+
+      const classList = getRawValue(node)
+      if (typeof classList !== 'string') return
+
+      const classNames = getClassNames(classList)
+      if (classNames.length <= 1) return
+
+      const seen = new Set()
+      const duplicates = new Set()
+
+      for (const className of classNames) {
+        if (seen.has(className)) {
+          duplicates.add(className)
+        } else {
+          seen.add(className)
+        }
+      }
+
+      if (duplicates.size === 0) return
+
+      context.report({
+        node,
+        messageId: 'duplicateClassName',
+        data: { name: [...duplicates].join(', ') },
+        fix: (fixer) => {
+          const sourceCode = context.getSourceCode()
+          const raw = sourceCode.text.slice(node.range[0], node.range[1])
+          return fixer.replaceText(node, removeDuplicateClassNames(raw))
+        }
+      })
+
+      return duplicates
+    }
+
+    return utils.defineTemplateBodyVisitor(context, {
+      /** @param {VAttribute} node */
+      "VAttribute[directive=false][key.name='class'][value.type='VLiteral']"(
+        node
+      ) {
+        reportDuplicateClasses(node.value)
+      },
+      /** @param {VDirective} node */
+      "VAttribute[directive=true][key.argument.name='class'][value.type='VExpressionContainer']"(
+        node
+      ) {
+        const parent = node.parent
+        const attrs = parent.attributes || []
+        const staticAttr = attrs.find(
+          (attr) =>
+            attr.key &&
+            attr.key.name === 'class' &&
+            attr.value &&
+            attr.value.type === 'VLiteral'
+        )
+
+        // get static classes
+        /** @type {Set<string> | null} */
+        let staticClasses = null
+        if (
+          staticAttr &&
+          staticAttr.value &&
+          staticAttr.value.type === 'VLiteral'
+        ) {
+          staticClasses = new Set(getClassNames(String(staticAttr.value.value)))
+        }
+
+        /** @type {Set<string>} */
+        const reported = new Set()
+
+        /** @type {Set<string>} */
+        const duplicatesInExpression = new Set()
+
+        /** @type {Map<string, ASTNode>} */
+        const seen = new Map()
+
+        /** @type {Map<string, {node: ASTNode, unconditional: boolean}>} */
+        const collected = new Map()
+
+        const classNodes = extractClassNodes(node)
+        for (const { node: reportNode, unconditional } of classNodes) {
+          // report fixable duplicates and collect reported class names
+          const reportedClasses = reportDuplicateClasses(reportNode)
+          if (reportedClasses) {
+            for (const classes of reportedClasses) reported.add(classes)
+          }
+
+          // collect all class names and check for cross nodes duplicates
+          const classList = getRawValue(reportNode)
+          if (typeof classList !== 'string') continue
+          const classNames = getClassNames(classList)
+
+          for (const className of classNames) {
+            // skip if already reported by reportDuplicateClasses
+            if (reported.has(className)) continue
+            const existing = collected.get(className)
+            if (existing) {
+              // only add duplicate if at least one is unconditional
+              if (existing.unconditional || unconditional) {
+                duplicatesInExpression.add(className)
+              }
+            } else {
+              collected.set(className, {
+                node: reportNode.parent,
+                unconditional
+              })
+            }
+            // track unconditional duplicates separately for reporting
+            if (unconditional) {
+              if (seen.has(className)) {
+                duplicatesInExpression.add(className)
+              } else {
+                seen.set(className, reportNode.parent)
+              }
+            }
+          }
+
+          // report cross attribute duplicates
+          if (staticClasses) {
+            const intersection = classNames.filter((n) => staticClasses.has(n))
+            if (intersection.length > 0 && parent) {
+              context.report({
+                node: parent,
+                messageId: 'duplicateClassName',
+                data: { name: intersection.join(', ') }
+              })
+            }
+          }
+        }
+
+        // report cross node duplicates
+        for (const className of duplicatesInExpression) {
+          const reportNode =
+            seen.get(className) || collected.get(className)?.node
+          if (reportNode) {
+            context.report({
+              node: reportNode,
+              messageId: 'duplicateClassName',
+              data: { name: className }
+            })
+          }
+        }
+      }
+    })
+  }
+}
diff --git a/tests/lib/rules/no-duplicate-class-names.js b/tests/lib/rules/no-duplicate-class-names.js
new file mode 100644
index 000000000..03491a55f
--- /dev/null
+++ b/tests/lib/rules/no-duplicate-class-names.js
@@ -0,0 +1,361 @@
+/**
+ * @author Yizack Rangel
+ * See LICENSE file in root directory for full license.
+ */
+'use strict'
+
+const RuleTester = require('../../eslint-compat').RuleTester
+const rule = require('../../../lib/rules/no-duplicate-class-names')
+
+const tester = new RuleTester({
+  languageOptions: {
+    parser: require('vue-eslint-parser'),
+    ecmaVersion: 2020,
+    sourceType: 'module'
+  }
+})
+
+tester.run('no-duplicate-class-names', rule, {
+  valid: [
+    {
+      filename: 'no-classes.vue',
+      code: '<template><div></div></template>'
+    },
+    {
+      filename: 'one-class.vue',
+      code: '<template><div class="foo"></div></template>'
+    },
+    {
+      filename: 'multiple-different-classes.vue',
+      code: '<template><div class="foo bar baz"></div></template>'
+    },
+    {
+      filename: 'no-duplicate-class-in-directive-string.vue',
+      code: `<template><div :class="'foo bar baz'"></div></template>`
+    },
+    {
+      filename: 'no-duplicate-class-in-directive-literal.vue',
+      code: '<template><div :class="`foo bar baz`"></div></template>'
+    },
+    {
+      filename: 'no-duplicate-class-in-directive-object.vue',
+      code: `<template><div :class="{ 'foo bar baz': true }"></div></template>`
+    },
+    {
+      filename: 'duplicate-class-in-different-directive-object-keys.vue',
+      code: `<template><div :class="{ 'foo': true, 'foo bar': true }"></div></template>`
+    },
+    {
+      filename: 'class-conditional-expression.vue',
+      code: `<template><div :class="isActive ? 'foo' : 'bar'"></div></template>`
+    },
+    {
+      filename: 'class-conditional-duplicate-expression-value.vue',
+      code: `<template><div :class="isActive ? 'foo' : 'foo'"></div></template>`
+    },
+    {
+      filename: 'class-object-duplicate-value.vue',
+      code: `<div :class="{ 'foo bar': isActive, 'foo': isAnotherActive }"></div>`
+    }
+  ],
+  invalid: [
+    {
+      filename: 'duplicate-class.vue',
+      code: '<template><div class="foo foo"></div></template>',
+      output: '<template><div class="foo"></div></template>',
+      errors: [
+        {
+          message: "Duplicate class name 'foo'.",
+          type: 'VLiteral'
+        }
+      ]
+    },
+    {
+      filename: 'multiple-duplicate-classes.vue',
+      code: '<template><div class="foo bar foo baz bar"></div></template>',
+      output: '<template><div class="foo bar baz"></div></template>',
+      errors: [
+        {
+          message: "Duplicate class name 'foo, bar'.",
+          type: 'VLiteral'
+        }
+      ]
+    },
+    {
+      filename: 'duplicate-class-in-directive-string.vue',
+      code: `<template><div :class="'foo foo'"></div></template>`,
+      output: `<template><div :class="'foo'"></div></template>`,
+      errors: [
+        {
+          message: "Duplicate class name 'foo'.",
+          type: 'Literal'
+        }
+      ]
+    },
+    {
+      filename: 'duplicate-class-in-directive-literal.vue',
+      code: '<template><div :class="`foo foo`"></div></template>',
+      output: '<template><div :class="`foo`"></div></template>',
+      errors: [
+        {
+          message: "Duplicate class name 'foo'.",
+          type: 'TemplateElement'
+        }
+      ]
+    },
+    {
+      filename: 'duplicate-class-directive-object-key.vue',
+      code: `<template><div :class="{ 'foo foo': true }"></div></template>`,
+      output: `<template><div :class="{ 'foo': true }"></div></template>`,
+      errors: [
+        {
+          message: "Duplicate class name 'foo'.",
+          type: 'Literal'
+        }
+      ]
+    },
+    {
+      filename: 'multiple-duplicate-class-directive-object-keys.vue',
+      code: `<template><div :class="{ 'foo foo bar': true, 'bar bar baz': true }"></div></template>`,
+      output: `<template><div :class="{ 'foo bar': true, 'bar baz': true }"></div></template>`,
+      errors: [
+        {
+          message: "Duplicate class name 'foo'.",
+          type: 'Literal'
+        },
+        {
+          message: "Duplicate class name 'bar'.",
+          type: 'Literal'
+        }
+      ]
+    },
+    {
+      filename: 'duplicate-class-directive-array-item.vue',
+      code: `<template><div :class="['foo foo']"></div></template>`,
+      output: `<template><div :class="['foo']"></div></template>`,
+      errors: [
+        {
+          message: "Duplicate class name 'foo'.",
+          type: 'Literal'
+        }
+      ]
+    },
+    {
+      filename: 'multiple-duplicate-classes-directive-array-items.vue',
+      code: `<template><div :class="['foo foo', 'bar bar baz']"></div></template>`,
+      output: `<template><div :class="['foo', 'bar baz']"></div></template>`,
+      errors: [
+        {
+          message: "Duplicate class name 'foo'.",
+          type: 'Literal'
+        },
+        {
+          message: "Duplicate class name 'bar'.",
+          type: 'Literal'
+        }
+      ]
+    },
+    {
+      filename: 'duplicate-class-in-mixed-directive.vue',
+      code: `<template><div :class="['foo foo', { 'bar bar baz': true }]"></div></template>`,
+      output: `<template><div :class="['foo', { 'bar baz': true }]"></div></template>`,
+      errors: [
+        {
+          message: "Duplicate class name 'foo'.",
+          type: 'Literal'
+        },
+        {
+          message: "Duplicate class name 'bar'.",
+          type: 'Literal'
+        }
+      ]
+    },
+    {
+      filename: 'duplicate-class-conditional-expression.vue',
+      code: `<template><div :class="isActive ? 'foo foo' : 'bar'"></div></template>`,
+      output: `<template><div :class="isActive ? 'foo' : 'bar'"></div></template>`,
+      errors: [
+        {
+          message: "Duplicate class name 'foo'.",
+          type: 'Literal'
+        }
+      ]
+    },
+    {
+      filename: 'duplicate-class-binary-expression.vue',
+      code: `<template><div :class="'foo foo ' + ' bar'"></div></template>`,
+      output: `<template><div :class="'foo ' + ' bar'"></div></template>`,
+      errors: [
+        {
+          message: "Duplicate class name 'foo'.",
+          type: 'Literal'
+        }
+      ]
+    },
+    {
+      filename: 'duplicate-class-preserved-spaces-1.vue',
+      code: `<template><div class="foo foo     bar"></div></template>`,
+      output: `<template><div class="foo     bar"></div></template>`,
+      errors: [
+        {
+          message: "Duplicate class name 'foo'.",
+          type: 'VLiteral'
+        }
+      ]
+    },
+    {
+      filename: 'duplicate-class-preserved-spaces-2.vue',
+      code: `<template><div class="foo bar    baz foo"></div></template>`,
+      output: `<template><div class="foo bar    baz"></div></template>`,
+      errors: [
+        {
+          message: "Duplicate class name 'foo'.",
+          type: 'VLiteral'
+        }
+      ]
+    },
+    {
+      filename: 'duplicate-class-preserved-spaces-3.vue',
+      code: `<template><div class="foo bar foo     baz"></div></template>`,
+      output: `<template><div class="foo bar     baz"></div></template>`,
+      errors: [
+        {
+          message: "Duplicate class name 'foo'.",
+          type: 'VLiteral'
+        }
+      ]
+    },
+    {
+      filename: 'duplicate-class-cross-attribute-string.vue',
+      code: `<template><div class="foo" :class="'foo'"></div></template>`,
+      output: null,
+      errors: [
+        {
+          message: "Duplicate class name 'foo'.",
+          type: 'VStartTag'
+        }
+      ]
+    },
+    {
+      filename: 'duplicate-class-cross-attribute-literal.vue',
+      code: '<template><div class="foo" :class="`foo`"></div></template>',
+      output: null,
+      errors: [
+        {
+          message: "Duplicate class name 'foo'.",
+          type: 'VStartTag'
+        }
+      ]
+    },
+    {
+      filename: 'duplicate-class-cross-attribute.vue',
+      code: `<template><div class="foo" :class="'foo bar'"></div></template>`,
+      output: null,
+      errors: [
+        {
+          message: "Duplicate class name 'foo'.",
+          type: 'VStartTag'
+        }
+      ]
+    },
+    {
+      filename: 'duplicate-class-cross-attribute-multiple-duplicates.vue',
+      code: `<template><div class="foo bar" :class="'foo bar'"></div></template>`,
+      output: null,
+      errors: [
+        {
+          message: "Duplicate class name 'foo, bar'.",
+          type: 'VStartTag'
+        }
+      ]
+    },
+    {
+      filename: 'duplicate-class-cross-attribute-array.vue',
+      code: `<template><div class="foo" :class="['foo', 'bar']"></div></template>`,
+      output: null,
+      errors: [
+        {
+          message: "Duplicate class name 'foo'.",
+          type: 'VStartTag'
+        }
+      ]
+    },
+    {
+      filename: 'duplicate-class-cross-attribute-object.vue',
+      code: `<template><div class="foo" :class="{ 'foo': true }"></div></template>`,
+      output: null,
+      errors: [
+        {
+          message: "Duplicate class name 'foo'.",
+          type: 'VStartTag'
+        }
+      ]
+    },
+    {
+      filename: 'duplicate-class-cross-attribute-mixed.vue',
+      code: `<template><div class="foo" :class="['foo', { 'bar': true }]"></div></template>`,
+      output: null,
+      errors: [
+        {
+          message: "Duplicate class name 'foo'.",
+          type: 'VStartTag'
+        }
+      ]
+    },
+    {
+      filename: 'duplicate-class-cross-attribute-binary.vue',
+      code: `<template><div class="foo" :class="'foo ' + 'bar'"></div></template>`,
+      output: null,
+      errors: [
+        {
+          message: "Duplicate class name 'foo'.",
+          type: 'VStartTag'
+        }
+      ]
+    },
+    {
+      filename: 'duplicate-class-cross-attribute-conditional.vue',
+      code: `<template><div class="foo" :class="isActive ? 'foo' : 'bar'"></div></template>`,
+      output: null,
+      errors: [
+        {
+          message: "Duplicate class name 'foo'.",
+          type: 'VStartTag'
+        }
+      ]
+    },
+    {
+      filename: 'duplicate-class-cross-node-array.vue',
+      code: `<template><div :class="['foo', 'foo']"></div></template>`,
+      output: null,
+      errors: [
+        {
+          message: "Duplicate class name 'foo'.",
+          type: 'ArrayExpression'
+        }
+      ]
+    },
+    {
+      filename: 'duplicate-class-cross-node-binary.vue',
+      code: `<template><div :class="'foo ' + 'foo'"></div></template>`,
+      output: null,
+      errors: [
+        {
+          message: "Duplicate class name 'foo'.",
+          type: 'BinaryExpression'
+        }
+      ]
+    },
+    {
+      filename: 'duplicate-class-cross-node-mixed.vue',
+      code: `<template><div :class="['foo', { 'foo': true }]"></div></template>`,
+      output: null,
+      errors: [
+        {
+          message: "Duplicate class name 'foo'.",
+          type: 'ArrayExpression'
+        }
+      ]
+    }
+  ]
+})