diff --git a/src/Generator.Tests/Passes/TestPasses.cs b/src/Generator.Tests/Passes/TestPasses.cs
index 121e311e..d185a32c 100644
--- a/src/Generator.Tests/Passes/TestPasses.cs
+++ b/src/Generator.Tests/Passes/TestPasses.cs
@@ -1,6 +1,7 @@
 using System.Linq;
 using CppSharp;
 using CppSharp.Passes;
+using CppSharp.AST;
 using NUnit.Framework;
 
 namespace CppSharp.Generator.Tests.Passes
@@ -158,5 +159,35 @@ namespace CppSharp.Generator.Tests.Passes
             Assert.IsFalse(AstContext.FindClass(className).First().Properties.Find(
                 m => m.Name == "ReadOnlyPropertyMethod").HasSetter);
         }
+
+        [Test]
+        public void TestCheckAmbiguousFunctionsPass()
+        {
+            passBuilder.AddPass(new CheckAmbiguousFunctions());
+            passBuilder.RunPasses(pass => pass.VisitLibrary(AstContext));
+            var @class = AstContext.FindClass("TestCheckAmbiguousFunctionsPass").FirstOrDefault();
+            Assert.IsNotNull(@class);
+            var overloads = @class.Methods.Where(m => m.Name == "Method");
+            var constMethod = overloads
+                .Where(m => m.IsConst && m.Parameters.Count == 0)
+                .FirstOrDefault();
+            var nonConstMethod = overloads
+                .Where(m => !m.IsConst && m.Parameters.Count == 0)
+                .FirstOrDefault();
+            Assert.IsNotNull(constMethod);
+            Assert.IsNotNull(nonConstMethod);
+            Assert.IsTrue(constMethod.GenerationKind == GenerationKind.None);
+            Assert.IsTrue(nonConstMethod.GenerationKind == GenerationKind.Generate);
+            var constMethodWithParam = overloads
+                .Where(m => m.IsConst && m.Parameters.Count == 1)
+                .FirstOrDefault();
+            var nonConstMethodWithParam = overloads
+                .Where(m => !m.IsConst && m.Parameters.Count == 1)
+                .FirstOrDefault();
+            Assert.IsNotNull(constMethodWithParam);
+            Assert.IsNotNull(nonConstMethodWithParam);
+            Assert.IsTrue(constMethodWithParam.GenerationKind == GenerationKind.None);
+            Assert.IsTrue(nonConstMethodWithParam.GenerationKind == GenerationKind.Generate);
+        }
     }
 }
diff --git a/src/Generator/Passes/CheckAmbiguousFunctions.cs b/src/Generator/Passes/CheckAmbiguousFunctions.cs
index f0c67a89..5627dbaf 100644
--- a/src/Generator/Passes/CheckAmbiguousFunctions.cs
+++ b/src/Generator/Passes/CheckAmbiguousFunctions.cs
@@ -44,10 +44,10 @@ namespace CppSharp.Passes
 
                 if (!overload.IsGenerated) continue;
 
-                if (!CheckDefaultParameters(function, overload))
+                if (!CheckConstness(function, overload))
                     continue;
 
-                if (!CheckConstness(function, overload))
+                if (!CheckDefaultParameters(function, overload))
                     continue;
 
                 function.IsAmbiguous = true;
diff --git a/tests/Native/Passes.h b/tests/Native/Passes.h
index 4d288b89..eba7caf1 100644
--- a/tests/Native/Passes.h
+++ b/tests/Native/Passes.h
@@ -52,3 +52,12 @@ enum
     UnnamedEnumB1,
     EnumUnnamedB2
 };
+
+struct TestCheckAmbiguousFunctionsPass
+{
+    // Tests removal of const method overloads
+    int Method();
+    int Method() const;
+    int Method(int x);
+    int Method(int x) const;
+};