1 files changed, 110 insertions, 0 deletions
diff --git a/clang-tools-extra/test/cpp11-migrate/AddOverride/basic.cpp b/clang-tools-extra/test/cpp11-migrate/AddOverride/basic.cpp
new file mode 100644
index 00000000000..1c3616bfcbb
--- /dev/null
+++ b/clang-tools-extra/test/cpp11-migrate/AddOverride/basic.cpp
@@ -0,0 +1,110 @@
+// RUN: grep -Ev "// *[A-Z-]+:" %s > %t.cpp
+// RUN: cpp11-migrate -add-override %t.cpp -- -I %S -std=c++11
+// RUN: FileCheck -input-file=%t.cpp %s
+
+class A {
+public:
+  virtual ~A();
+  // CHECK: virtual ~A();
+  void f();
+  virtual void h() const;
+  // CHECK: virtual void h() const;
+  virtual void i() = 0;
+  // CHECK: virtual void i() = 0;
+};
+
+// Test that override isn't added to non-virtual functions.
+class B : public A {
+public:
+  void f();
+  // CHECK: class B
+  // CHECK: void f();
+};
+
+// Test that override is added to functions that override virtual functions.
+class C : public A {
+public:
+  void h() const;
+  // CHECK: class C
+  // CHECK: void h() const override;
+};
+
+// Test that override isn't add to functions that overload but not override.
+class D : public A {
+public:
+  void h();
+  // CHECK: class D
+  // CHECK: void h();
+};
+
+// Test that override isn't added again to functions that already have it.
+class E : public A {
+public:
+  void h() const override;
+  // CHECK: class E
+  // CHECK: void h() const override;
+};
+
+// Test that override isn't added to the destructor.
+class F : public A {
+public:
+  virtual ~F();
+  // CHECK: class F
+  // CHECK: virtual ~F();
+};
+
+// Test that override is placed before any end of line comments.
+class G : public A {
+public:
+  void h() const; // comment
+  // CHECK: class G
+  // CHECK: void h() const override; // comment
+};
+
+// Test that override is placed correctly if there is an inline body.
+class H : public A {
+public:
+  void h() const { }
+  // CHECK: class H
+  // CHECK: void h() const override { }
+};
+
+// Test that override is placed correctly if there is a body on the next line.
+class I : public A {
+public:
+  void h() const
+  { }
+  // CHECK: class I
+  // CHECK: void h() const override
+  // CHECK: { }
+};
+
+// Test that override is placed correctly if there is a body outside the class.
+class J : public A {
+public:
+  void h() const;
+  // CHECK: class J
+  // CHECK: void h() const override;
+};
+
+void J::h() const {
+  // CHECK: void J::h() const {
+}
+
+// Test that override is placed correctly if there is a trailing return type.
+class K : public A {
+public:
+  auto h() const -> void;
+  // CHECK: class K
+  // CHECK: auto h() const -> void override;
+};
+
+// Test that override isn't added if it is already specified via a macro.
+class L : public A {
+public:
+#define LLVM_OVERRIDE override
+  void h() const LLVM_OVERRIDE;
+  // CHECK: class L
+  // CHECK: void h() const LLVM_OVERRIDE;
+};
+