diff --git a/unittests/ASTMatchers/Dynamic/ParserTest.cpp b/unittests/ASTMatchers/Dynamic/ParserTest.cpp
index 310108a..b20c1ac 100644
--- a/unittests/ASTMatchers/Dynamic/ParserTest.cpp
+++ b/unittests/ASTMatchers/Dynamic/ParserTest.cpp
@@ -96,6 +96,21 @@
   llvm::StringMap<uint64_t> ExpectedMatchers;
 };
 
+TEST(ParserTest, ParseUnsigned) {
+  MockSema Sema;
+  Sema.parse("0");
+  Sema.parse("123");
+  Sema.parse("0x1f");
+  Sema.parse("12345678901");
+  Sema.parse("1a1");
+  EXPECT_EQ(5U, Sema.Values.size());
+  EXPECT_EQ(0U, Sema.Values[0].getUnsigned());
+  EXPECT_EQ(123U, Sema.Values[1].getUnsigned());
+  EXPECT_EQ(31U, Sema.Values[2].getUnsigned());
+  EXPECT_EQ("1:1: Error parsing unsigned token: <12345678901>", Sema.Errors[3]);
+  EXPECT_EQ("1:1: Error parsing unsigned token: <1a1>", Sema.Errors[4]);
+}
+
 TEST(ParserTest, ParseString) {
   MockSema Sema;
   Sema.parse("\"Foo\"");
@@ -122,7 +137,7 @@
   const uint64_t ExpectedFoo = Sema.expectMatcher("Foo");
   const uint64_t ExpectedBar = Sema.expectMatcher("Bar");
   const uint64_t ExpectedBaz = Sema.expectMatcher("Baz");
-  Sema.parse(" Foo ( Bar (), Baz( \n \"B A,Z\") ) .bind( \"Yo!\") ");
+  Sema.parse(" Foo ( Bar ( 17), Baz( \n \"B A,Z\") ) .bind( \"Yo!\") ");
   for (size_t i = 0, e = Sema.Errors.size(); i != e; ++i) {
     EXPECT_EQ("", Sema.Errors[i]);
   }
@@ -135,12 +150,13 @@
   EXPECT_EQ(3ULL, Sema.Matchers.size());
   const MockSema::MatcherInfo Bar = Sema.Matchers[0];
   EXPECT_EQ("Bar", Bar.MatcherName);
-  EXPECT_TRUE(matchesRange(Bar.NameRange, 1, 1, 8, 14));
-  EXPECT_EQ(0ULL, Bar.Args.size());
+  EXPECT_TRUE(matchesRange(Bar.NameRange, 1, 1, 8, 17));
+  EXPECT_EQ(1ULL, Bar.Args.size());
+  EXPECT_EQ(17U, Bar.Args[0].Value.getUnsigned());
 
   const MockSema::MatcherInfo Baz = Sema.Matchers[1];
   EXPECT_EQ("Baz", Baz.MatcherName);
-  EXPECT_TRUE(matchesRange(Baz.NameRange, 1, 2, 16, 10));
+  EXPECT_TRUE(matchesRange(Baz.NameRange, 1, 2, 19, 10));
   EXPECT_EQ(1ULL, Baz.Args.size());
   EXPECT_EQ("B A,Z", Baz.Args[0].Value.getString());
 
@@ -161,6 +177,11 @@
   EXPECT_TRUE(matchesDynamic("int x = 1 + false;", *Matcher));
   EXPECT_FALSE(matchesDynamic("int x = true + 1;", *Matcher));
 
+  Matcher.reset(
+      Parser::parseMatcherExpression("hasParameter(1, hasName(\"x\"))", NULL));
+  EXPECT_TRUE(matchesDynamic("void f(int a, int x);", *Matcher));
+  EXPECT_FALSE(matchesDynamic("void f(int x, int a);", *Matcher));
+
   Diagnostics Error;
   EXPECT_TRUE(Parser::parseMatcherExpression(
       "hasInitializer(\n    binaryOperator(hasLHS(\"A\")))", &Error) == NULL);
diff --git a/unittests/ASTMatchers/Dynamic/RegistryTest.cpp b/unittests/ASTMatchers/Dynamic/RegistryTest.cpp
index 64af120..1055233 100644
--- a/unittests/ASTMatchers/Dynamic/RegistryTest.cpp
+++ b/unittests/ASTMatchers/Dynamic/RegistryTest.cpp
@@ -63,6 +63,10 @@
       constructMatcher("hasName", std::string("X"), NULL));
   EXPECT_TRUE(matchesDynamic("class X {};", *Value));
   EXPECT_FALSE(matchesDynamic("int x;", *Value));
+
+  Value.reset(constructMatcher("parameterCountIs", 2, NULL));
+  EXPECT_TRUE(matchesDynamic("void foo(int,int);", *Value));
+  EXPECT_FALSE(matchesDynamic("void foo(int);", *Value));
 }
 
 TEST(RegistryTest, ConstructWithMatcherArgs) {
@@ -82,6 +86,11 @@
   code = "int y(); int i = y();";
   EXPECT_TRUE(matchesDynamic(code, *HasInitializerSimple));
   EXPECT_TRUE(matchesDynamic(code, *HasInitializerComplex));
+
+  OwningPtr<DynTypedMatcher> HasParameter(
+      constructMatcher("hasParameter", 1, hasName("x"), NULL));
+  EXPECT_TRUE(matchesDynamic("void f(int a, int x);", *HasParameter));
+  EXPECT_FALSE(matchesDynamic("void f(int x, int a);", *HasParameter));
 }
 
 TEST(RegistryTest, Errors) {
diff --git a/unittests/ASTMatchers/Dynamic/VariantValueTest.cpp b/unittests/ASTMatchers/Dynamic/VariantValueTest.cpp
index 6c202e5..2aa0e42 100644
--- a/unittests/ASTMatchers/Dynamic/VariantValueTest.cpp
+++ b/unittests/ASTMatchers/Dynamic/VariantValueTest.cpp
@@ -19,6 +19,19 @@
 using ast_matchers::internal::DynTypedMatcher;
 using ast_matchers::internal::Matcher;
 
+TEST(VariantValueTest, Unsigned) {
+  const unsigned kUnsigned = 17;
+  VariantValue Value = kUnsigned;
+
+  EXPECT_TRUE(Value.isUnsigned());
+  EXPECT_EQ(kUnsigned, Value.getUnsigned());
+
+  EXPECT_FALSE(Value.isString());
+  EXPECT_FALSE(Value.isMatcher());
+  EXPECT_FALSE(Value.isTypedMatcher<clang::Decl>());
+  EXPECT_FALSE(Value.isTypedMatcher<clang::UnaryOperator>());
+}
+
 TEST(VariantValueTest, String) {
   const ::std::string kString = "string";
   VariantValue Value = kString;
@@ -26,6 +39,7 @@
   EXPECT_TRUE(Value.isString());
   EXPECT_EQ(kString, Value.getString());
 
+  EXPECT_FALSE(Value.isUnsigned());
   EXPECT_FALSE(Value.isMatcher());
   EXPECT_FALSE(Value.isTypedMatcher<clang::Decl>());
   EXPECT_FALSE(Value.isTypedMatcher<clang::UnaryOperator>());
@@ -34,6 +48,7 @@
 TEST(VariantValueTest, DynTypedMatcher) {
   VariantValue Value = stmt();
 
+  EXPECT_FALSE(Value.isUnsigned());
   EXPECT_FALSE(Value.isString());
 
   EXPECT_TRUE(Value.isMatcher());
@@ -59,15 +74,24 @@
   VariantValue Value = std::string("A");
   EXPECT_TRUE(Value.isString());
   EXPECT_EQ("A", Value.getString());
+  EXPECT_FALSE(Value.isUnsigned());
   EXPECT_FALSE(Value.isMatcher());
 
   Value = recordDecl();
+  EXPECT_FALSE(Value.isUnsigned());
   EXPECT_FALSE(Value.isString());
   EXPECT_TRUE(Value.isMatcher());
   EXPECT_TRUE(Value.isTypedMatcher<clang::Decl>());
   EXPECT_TRUE(Value.isTypedMatcher<clang::UnaryOperator>());
 
+  Value = 17;
+  EXPECT_TRUE(Value.isUnsigned());
+  EXPECT_EQ(17U, Value.getUnsigned());
+  EXPECT_FALSE(Value.isMatcher());
+  EXPECT_FALSE(Value.isString());
+
   Value = VariantValue();
+  EXPECT_FALSE(Value.isUnsigned());
   EXPECT_FALSE(Value.isString());
   EXPECT_FALSE(Value.isMatcher());
 }