c++/src/kj/parse/common-test.c++ - toolchain/capnproto - Git at Google

 // Copyright (c) 2013-2014 Sandstorm Development Group, Inc. and contributors
 // Licensed under the MIT License:
 //
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
 // in the Software without restriction, including without limitation the rights
 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 // copies of the Software, and to permit persons to whom the Software is
 // furnished to do so, subject to the following conditions:
 //
 // The above copyright notice and this permission notice shall be included in
 // all copies or substantial portions of the Software.
 //
 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 // THE SOFTWARE.

 #include "common.h"
 #include "../string.h"
 #include <kj/compat/gtest.h>

 namespace kj {
 namespace parse {
 namespace {

 typedef IteratorInput<char, const char*> Input;

 TEST(CommonParsers, AnyParser) {
   StringPtr text = "foo";
   Input input(text.begin(), text.end());
   constexpr auto parser = any;

   Maybe<char> result = parser(input);
   KJ_IF_MAYBE(c, result) {
     EXPECT_EQ('f', *c);
   } else {
     ADD_FAILURE() << "Expected 'c', got null.";
   }
   EXPECT_FALSE(input.atEnd());

   result = parser(input);
   KJ_IF_MAYBE(c, result) {
     EXPECT_EQ('o', *c);
   } else {
     ADD_FAILURE() << "Expected 'o', got null.";
   }
   EXPECT_FALSE(input.atEnd());

   result = parser(input);
   KJ_IF_MAYBE(c, result) {
     EXPECT_EQ('o', *c);
   } else {
     ADD_FAILURE() << "Expected 'o', got null.";
   }
   EXPECT_TRUE(input.atEnd());

   result = parser(input);
   EXPECT_TRUE(result == nullptr);
   EXPECT_TRUE(input.atEnd());
 }

 TEST(CommonParsers, ExactElementParser) {
   StringPtr text = "foo";
   Input input(text.begin(), text.end());

   Maybe<Tuple<>> result = exactly('f')(input);
   EXPECT_TRUE(result != nullptr);
   EXPECT_FALSE(input.atEnd());

   result = exactly('o')(input);
   EXPECT_TRUE(result != nullptr);
   EXPECT_FALSE(input.atEnd());

   result = exactly('x')(input);
   EXPECT_TRUE(result == nullptr);
   EXPECT_FALSE(input.atEnd());

   auto parser = exactly('o');
   ParserRef<Input, Tuple<>> wrapped = ref<Input>(parser);
   result = wrapped(input);
   EXPECT_TRUE(result != nullptr);
   EXPECT_TRUE(input.atEnd());
 }

 TEST(CommonParsers, ExactlyConstParser) {
   StringPtr text = "foo";
   Input input(text.begin(), text.end());

   Maybe<Tuple<>> result = exactlyConst<char, 'f'>()(input);
   EXPECT_TRUE(result != nullptr);
   EXPECT_FALSE(input.atEnd());

   result = exactlyConst<char, 'o'>()(input);
   EXPECT_TRUE(result != nullptr);
   EXPECT_FALSE(input.atEnd());

   result = exactlyConst<char, 'x'>()(input);
   EXPECT_TRUE(result == nullptr);
   EXPECT_FALSE(input.atEnd());

   auto parser = exactlyConst<char, 'o'>();
   ParserRef<Input, Tuple<>> wrapped = ref<Input>(parser);
   result = wrapped(input);
   EXPECT_TRUE(result != nullptr);
   EXPECT_TRUE(input.atEnd());
 }

 TEST(CommonParsers, ConstResultParser) {
   auto parser = constResult(exactly('o'), 123);

   StringPtr text = "o";
   Input input(text.begin(), text.end());
   Maybe<int> result = parser(input);
   KJ_IF_MAYBE(i, result) {
     EXPECT_EQ(123, *i);
   } else {
     ADD_FAILURE() << "Expected 123, got null.";
   }
   EXPECT_TRUE(input.atEnd());
 }

 TEST(CommonParsers, DiscardParser) {
   auto parser = discard(any);

   StringPtr text = "o";
   Input input(text.begin(), text.end());
   Maybe<Tuple<>> result = parser(input);
   EXPECT_TRUE(result != nullptr);
   EXPECT_TRUE(input.atEnd());
 }

 TEST(CommonParsers, SequenceParser) {
   StringPtr text = "foo";

   {
     Input input(text.begin(), text.end());
     Maybe<Tuple<>> result = sequence(exactly('f'), exactly('o'), exactly('o'))(input);
     EXPECT_TRUE(result != nullptr);
     EXPECT_TRUE(input.atEnd());
   }

   {
     Input input(text.begin(), text.end());
     Maybe<Tuple<>> result = sequence(exactly('f'), exactly('o'))(input);
     EXPECT_TRUE(result != nullptr);
     EXPECT_FALSE(input.atEnd());
   }

   {
     Input input(text.begin(), text.end());
     Maybe<Tuple<>> result = sequence(exactly('x'), exactly('o'), exactly('o'))(input);
     EXPECT_TRUE(result == nullptr);
     EXPECT_FALSE(input.atEnd());
   }

   {
     Input input(text.begin(), text.end());
     Maybe<Tuple<>> result =
         sequence(sequence(exactly('f'), exactly('o')), exactly('o'))(input);
     EXPECT_TRUE(result != nullptr);
     EXPECT_TRUE(input.atEnd());
   }

   {
     Input input(text.begin(), text.end());
     Maybe<Tuple<>> result =
         sequence(sequence(exactly('f')), exactly('o'), exactly('o'))(input);
     EXPECT_TRUE(result != nullptr);
     EXPECT_TRUE(input.atEnd());
   }

   {
     Input input(text.begin(), text.end());
     Maybe<int> result = sequence(transform(exactly('f'), [](){return 123;}),
                                  exactly('o'), exactly('o'))(input);
     KJ_IF_MAYBE(i, result) {
       EXPECT_EQ(123, *i);
     } else {
       ADD_FAILURE() << "Expected 123, got null.";
     }
     EXPECT_TRUE(input.atEnd());
   }
 }

 TEST(CommonParsers, ManyParserCountOnly) {
   StringPtr text = "foooob";

   auto parser = sequence(exactly('f'), many(exactly('o')));

   {
     Input input(text.begin(), text.begin() + 3);
     Maybe<int> result = parser(input);
     KJ_IF_MAYBE(i, result) {
       EXPECT_EQ(2, *i);
     } else {
       ADD_FAILURE() << "Expected 2, got null.";
     }
     EXPECT_TRUE(input.atEnd());
   }

   {
     Input input(text.begin(), text.begin() + 5);
     Maybe<int> result = parser(input);
     KJ_IF_MAYBE(i, result) {
       EXPECT_EQ(4, *i);
     } else {
       ADD_FAILURE() << "Expected 4, got null.";
     }
     EXPECT_TRUE(input.atEnd());
   }

   {
     Input input(text.begin(), text.end());
     Maybe<int> result = parser(input);
     KJ_IF_MAYBE(i, result) {
       EXPECT_EQ(4, *i);
     } else {
       ADD_FAILURE() << "Expected 4, got null.";
     }
     EXPECT_FALSE(input.atEnd());
   }
 }

 TEST(CommonParsers, TimesParser) {
   StringPtr text = "foobar";

   auto parser = sequence(exactly('f'), times(any, 4));

   {
     Input input(text.begin(), text.begin() + 4);
     Maybe<Array<char>> result = parser(input);
     EXPECT_TRUE(result == nullptr);
     EXPECT_TRUE(input.atEnd());
   }

   {
     Input input(text.begin(), text.begin() + 5);
     Maybe<Array<char>> result = parser(input);
     KJ_IF_MAYBE(s, result) {
       EXPECT_EQ("ooba", heapString(*s));
     } else {
       ADD_FAILURE() << "Expected string, got null.";
     }
     EXPECT_TRUE(input.atEnd());
   }

   {
     Input input(text.begin(), text.end());
     Maybe<Array<char>> result = parser(input);
     KJ_IF_MAYBE(s, result) {
       EXPECT_EQ("ooba", heapString(*s));
     } else {
       ADD_FAILURE() << "Expected string, got null.";
     }
     EXPECT_FALSE(input.atEnd());
   }
 }

 TEST(CommonParsers, TimesParserCountOnly) {
   StringPtr text = "foooob";

   auto parser = sequence(exactly('f'), times(exactly('o'), 4));

   {
     Input input(text.begin(), text.begin() + 4);
     Maybe<Tuple<>> result = parser(input);
     EXPECT_TRUE(result == nullptr);
     EXPECT_TRUE(input.atEnd());
   }

   {
     Input input(text.begin(), text.begin() + 5);
     Maybe<Tuple<>> result = parser(input);
     EXPECT_TRUE(result != nullptr);
     EXPECT_TRUE(input.atEnd());
   }

   {
     Input input(text.begin(), text.end());
     Maybe<Tuple<>> result = parser(input);
     EXPECT_TRUE(result != nullptr);
     EXPECT_FALSE(input.atEnd());
   }

   text = "fooob";

   {
     Input input(text.begin(), text.end());
     Maybe<Tuple<>> result = parser(input);
     EXPECT_TRUE(result == nullptr);
     EXPECT_FALSE(input.atEnd());
   }
 }

 TEST(CommonParsers, ManyParserSubResult) {
   StringPtr text = "foooob";

   auto parser = many(any);

   {
     Input input(text.begin(), text.end());
     Maybe<Array<char>> result = parser(input);
     KJ_IF_MAYBE(chars, result) {
       EXPECT_EQ(text, heapString(*chars));
     } else {
       ADD_FAILURE() << "Expected char array, got null.";
     }
     EXPECT_TRUE(input.atEnd());
   }
 }

 TEST(CommonParsers, OptionalParser) {
   auto parser = sequence(
       transform(exactly('b'), []() -> uint { return 123; }),
       optional(transform(exactly('a'), []() -> uint { return 456; })),
       transform(exactly('r'), []() -> uint { return 789; }));

   {
     StringPtr text = "bar";
     Input input(text.begin(), text.end());
     Maybe<Tuple<uint, Maybe<uint>, uint>> result = parser(input);
     KJ_IF_MAYBE(value, result) {
       EXPECT_EQ(123u, get<0>(*value));
       KJ_IF_MAYBE(value2, get<1>(*value)) {
         EXPECT_EQ(456u, *value2);
       } else {
         ADD_FAILURE() << "Expected 456, got null.";
       }
       EXPECT_EQ(789u, get<2>(*value));
     } else {
       ADD_FAILURE() << "Expected result tuple, got null.";
     }
     EXPECT_TRUE(input.atEnd());
   }

   {
     StringPtr text = "br";
     Input input(text.begin(), text.end());
     Maybe<Tuple<uint, Maybe<uint>, uint>> result = parser(input);
     KJ_IF_MAYBE(value, result) {
       EXPECT_EQ(123u, get<0>(*value));
       EXPECT_TRUE(get<1>(*value) == nullptr);
       EXPECT_EQ(789u, get<2>(*value));
     } else {
       ADD_FAILURE() << "Expected result tuple, got null.";
     }
     EXPECT_TRUE(input.atEnd());
   }

   {
     StringPtr text = "bzr";
     Input input(text.begin(), text.end());
     Maybe<Tuple<uint, Maybe<uint>, uint>> result = parser(input);
     EXPECT_TRUE(result == nullptr);
   }
 }

 TEST(CommonParsers, OneOfParser) {
   auto parser = oneOf(
       transform(sequence(exactly('f'), exactly('o'), exactly('o')),
                 []() -> StringPtr { return "foo"; }),
       transform(sequence(exactly('b'), exactly('a'), exactly('r')),
                 []() -> StringPtr { return "bar"; }));

   {
     StringPtr text = "foo";
     Input input(text.begin(), text.end());
     Maybe<StringPtr> result = parser(input);
     KJ_IF_MAYBE(s, result) {
       EXPECT_EQ("foo", *s);
     } else {
       ADD_FAILURE() << "Expected 'foo', got null.";
     }
     EXPECT_TRUE(input.atEnd());
   }

   {
     StringPtr text = "bar";
     Input input(text.begin(), text.end());
     Maybe<StringPtr> result = parser(input);
     KJ_IF_MAYBE(s, result) {
       EXPECT_EQ("bar", *s);
     } else {
       ADD_FAILURE() << "Expected 'bar', got null.";
     }
     EXPECT_TRUE(input.atEnd());
   }
 }

 TEST(CommonParsers, TransformParser) {
   StringPtr text = "foo";

   auto parser = transformWithLocation(
       sequence(exactly('f'), exactly('o'), exactly('o')),
       [](Span<const char*> location) -> int {
         EXPECT_EQ("foo", StringPtr(location.begin(), location.end()));
         return 123;
       });

   {
     Input input(text.begin(), text.end());
     Maybe<int> result = parser(input);
     KJ_IF_MAYBE(i, result) {
       EXPECT_EQ(123, *i);
     } else {
       ADD_FAILURE() << "Expected 123, got null.";
     }
     EXPECT_TRUE(input.atEnd());
   }
 }

 TEST(CommonParsers, TransformOrRejectParser) {
   auto parser = transformOrReject(many(any),
       [](Array<char> chars) -> Maybe<int> {
         if (heapString(chars) == "foo") {
           return 123;
         } else {
           return nullptr;
         }
       });

   {
     StringPtr text = "foo";
     Input input(text.begin(), text.end());
     Maybe<int> result = parser(input);
     KJ_IF_MAYBE(i, result) {
       EXPECT_EQ(123, *i);
     } else {
       ADD_FAILURE() << "Expected 123, got null.";
     }
     EXPECT_TRUE(input.atEnd());
   }

   {
     StringPtr text = "bar";
     Input input(text.begin(), text.end());
     Maybe<int> result = parser(input);
     EXPECT_TRUE(result == nullptr);
     EXPECT_TRUE(input.atEnd());
   }
 }

 TEST(CommonParsers, References) {
   struct TransformFunc {
     int value;

     TransformFunc(int value): value(value) {}

     int operator()() const { return value; }
   };

   // Don't use auto for the parsers here in order to verify that the templates are properly choosing
   // whether to use references or copies.

   Transform_<Exactly_<char>, TransformFunc> parser1 =
       transform(exactly('f'), TransformFunc(12));

   auto otherParser = exactly('o');
   Transform_<Exactly_<char>&, TransformFunc> parser2 =
       transform(otherParser, TransformFunc(34));

   auto otherParser2 = exactly('b');
   Transform_<Exactly_<char>, TransformFunc> parser3 =
       transform(mv(otherParser2), TransformFunc(56));

   StringPtr text = "foob";
   auto parser = transform(
       sequence(parser1, parser2, exactly('o'), parser3),
       [](int i, int j, int k) { return i + j + k; });

   {
     Input input(text.begin(), text.end());
     Maybe<int> result = parser(input);
     KJ_IF_MAYBE(i, result) {
       EXPECT_EQ(12 + 34 + 56, *i);
     } else {
       ADD_FAILURE() << "Expected 12 + 34 + 56, got null.";
     }
     EXPECT_TRUE(input.atEnd());
   }
 }

 TEST(CommonParsers, NotLookingAt) {
   auto parser = notLookingAt(exactly('a'));

   {
     StringPtr text = "a";
     Input input(text.begin(), text.end());
     EXPECT_TRUE(parser(input) == nullptr);
     EXPECT_FALSE(input.atEnd());
   }

   {
     StringPtr text = "b";
     Input input(text.begin(), text.end());
     EXPECT_TRUE(parser(input) != nullptr);
     EXPECT_FALSE(input.atEnd());
   }
 }

 TEST(CommonParsers, EndOfInput) {
   auto parser = endOfInput;

   {
     StringPtr text = "a";
     Input input(text.begin(), text.end());
     EXPECT_TRUE(parser(input) == nullptr);
     EXPECT_TRUE(parser(input) == nullptr);
     input.next();
     EXPECT_FALSE(parser(input) == nullptr);
   }
 }

 }  // namespace
 }  // namespace parse
 }  // namespace kj
	// Copyright (c) 2013-2014 Sandstorm Development Group, Inc. and contributors
	// Licensed under the MIT License:
	//
	// Permission is hereby granted, free of charge, to any person obtaining a copy
	// of this software and associated documentation files (the "Software"), to deal
	// in the Software without restriction, including without limitation the rights
	// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	// copies of the Software, and to permit persons to whom the Software is
	// furnished to do so, subject to the following conditions:
	//
	// The above copyright notice and this permission notice shall be included in
	// all copies or substantial portions of the Software.
	//
	// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
	// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
	// THE SOFTWARE.

	#include "common.h"
	#include "../string.h"
	#include <kj/compat/gtest.h>

	namespace kj {
	namespace parse {
	namespace {

	typedef IteratorInput<char, const char*> Input;

	TEST(CommonParsers, AnyParser) {
	StringPtr text = "foo";
	Input input(text.begin(), text.end());
	constexpr auto parser = any;

	Maybe<char> result = parser(input);
	KJ_IF_MAYBE(c, result) {
	EXPECT_EQ('f', *c);
	} else {
	ADD_FAILURE() << "Expected 'c', got null.";
	}
	EXPECT_FALSE(input.atEnd());

	result = parser(input);
	KJ_IF_MAYBE(c, result) {
	EXPECT_EQ('o', *c);
	} else {
	ADD_FAILURE() << "Expected 'o', got null.";
	}
	EXPECT_FALSE(input.atEnd());

	result = parser(input);
	KJ_IF_MAYBE(c, result) {
	EXPECT_EQ('o', *c);
	} else {
	ADD_FAILURE() << "Expected 'o', got null.";
	}
	EXPECT_TRUE(input.atEnd());

	result = parser(input);
	EXPECT_TRUE(result == nullptr);
	EXPECT_TRUE(input.atEnd());
	}

	TEST(CommonParsers, ExactElementParser) {
	StringPtr text = "foo";
	Input input(text.begin(), text.end());

	Maybe<Tuple<>> result = exactly('f')(input);
	EXPECT_TRUE(result != nullptr);
	EXPECT_FALSE(input.atEnd());

	result = exactly('o')(input);
	EXPECT_TRUE(result != nullptr);
	EXPECT_FALSE(input.atEnd());

	result = exactly('x')(input);
	EXPECT_TRUE(result == nullptr);
	EXPECT_FALSE(input.atEnd());

	auto parser = exactly('o');
	ParserRef<Input, Tuple<>> wrapped = ref<Input>(parser);
	result = wrapped(input);
	EXPECT_TRUE(result != nullptr);
	EXPECT_TRUE(input.atEnd());
	}

	TEST(CommonParsers, ExactlyConstParser) {
	StringPtr text = "foo";
	Input input(text.begin(), text.end());

	Maybe<Tuple<>> result = exactlyConst<char, 'f'>()(input);
	EXPECT_TRUE(result != nullptr);
	EXPECT_FALSE(input.atEnd());

	result = exactlyConst<char, 'o'>()(input);
	EXPECT_TRUE(result != nullptr);
	EXPECT_FALSE(input.atEnd());

	result = exactlyConst<char, 'x'>()(input);
	EXPECT_TRUE(result == nullptr);
	EXPECT_FALSE(input.atEnd());

	auto parser = exactlyConst<char, 'o'>();
	ParserRef<Input, Tuple<>> wrapped = ref<Input>(parser);
	result = wrapped(input);
	EXPECT_TRUE(result != nullptr);
	EXPECT_TRUE(input.atEnd());
	}

	TEST(CommonParsers, ConstResultParser) {
	auto parser = constResult(exactly('o'), 123);

	StringPtr text = "o";
	Input input(text.begin(), text.end());
	Maybe<int> result = parser(input);
	KJ_IF_MAYBE(i, result) {
	EXPECT_EQ(123, *i);
	} else {
	ADD_FAILURE() << "Expected 123, got null.";
	}
	EXPECT_TRUE(input.atEnd());
	}

	TEST(CommonParsers, DiscardParser) {
	auto parser = discard(any);

	StringPtr text = "o";
	Input input(text.begin(), text.end());
	Maybe<Tuple<>> result = parser(input);
	EXPECT_TRUE(result != nullptr);
	EXPECT_TRUE(input.atEnd());
	}

	TEST(CommonParsers, SequenceParser) {
	StringPtr text = "foo";

	{
	Input input(text.begin(), text.end());
	Maybe<Tuple<>> result = sequence(exactly('f'), exactly('o'), exactly('o'))(input);
	EXPECT_TRUE(result != nullptr);
	EXPECT_TRUE(input.atEnd());
	}

	{
	Input input(text.begin(), text.end());
	Maybe<Tuple<>> result = sequence(exactly('f'), exactly('o'))(input);
	EXPECT_TRUE(result != nullptr);
	EXPECT_FALSE(input.atEnd());
	}

	{
	Input input(text.begin(), text.end());
	Maybe<Tuple<>> result = sequence(exactly('x'), exactly('o'), exactly('o'))(input);
	EXPECT_TRUE(result == nullptr);
	EXPECT_FALSE(input.atEnd());
	}

	{
	Input input(text.begin(), text.end());
	Maybe<Tuple<>> result =
	sequence(sequence(exactly('f'), exactly('o')), exactly('o'))(input);
	EXPECT_TRUE(result != nullptr);
	EXPECT_TRUE(input.atEnd());
	}

	{
	Input input(text.begin(), text.end());
	Maybe<Tuple<>> result =
	sequence(sequence(exactly('f')), exactly('o'), exactly('o'))(input);
	EXPECT_TRUE(result != nullptr);
	EXPECT_TRUE(input.atEnd());
	}

	{
	Input input(text.begin(), text.end());
	Maybe<int> result = sequence(transform(exactly('f'), [](){return 123;}),
	exactly('o'), exactly('o'))(input);
	KJ_IF_MAYBE(i, result) {
	EXPECT_EQ(123, *i);
	} else {
	ADD_FAILURE() << "Expected 123, got null.";
	}
	EXPECT_TRUE(input.atEnd());
	}
	}

	TEST(CommonParsers, ManyParserCountOnly) {
	StringPtr text = "foooob";

	auto parser = sequence(exactly('f'), many(exactly('o')));

	{
	Input input(text.begin(), text.begin() + 3);
	Maybe<int> result = parser(input);
	KJ_IF_MAYBE(i, result) {
	EXPECT_EQ(2, *i);
	} else {
	ADD_FAILURE() << "Expected 2, got null.";
	}
	EXPECT_TRUE(input.atEnd());
	}

	{
	Input input(text.begin(), text.begin() + 5);
	Maybe<int> result = parser(input);
	KJ_IF_MAYBE(i, result) {
	EXPECT_EQ(4, *i);
	} else {
	ADD_FAILURE() << "Expected 4, got null.";
	}
	EXPECT_TRUE(input.atEnd());
	}

	{
	Input input(text.begin(), text.end());
	Maybe<int> result = parser(input);
	KJ_IF_MAYBE(i, result) {
	EXPECT_EQ(4, *i);
	} else {
	ADD_FAILURE() << "Expected 4, got null.";
	}
	EXPECT_FALSE(input.atEnd());
	}
	}

	TEST(CommonParsers, TimesParser) {
	StringPtr text = "foobar";

	auto parser = sequence(exactly('f'), times(any, 4));

	{
	Input input(text.begin(), text.begin() + 4);
	Maybe<Array<char>> result = parser(input);
	EXPECT_TRUE(result == nullptr);
	EXPECT_TRUE(input.atEnd());
	}

	{
	Input input(text.begin(), text.begin() + 5);
	Maybe<Array<char>> result = parser(input);
	KJ_IF_MAYBE(s, result) {
	EXPECT_EQ("ooba", heapString(*s));
	} else {
	ADD_FAILURE() << "Expected string, got null.";
	}
	EXPECT_TRUE(input.atEnd());
	}

	{
	Input input(text.begin(), text.end());
	Maybe<Array<char>> result = parser(input);
	KJ_IF_MAYBE(s, result) {
	EXPECT_EQ("ooba", heapString(*s));
	} else {
	ADD_FAILURE() << "Expected string, got null.";
	}
	EXPECT_FALSE(input.atEnd());
	}
	}

	TEST(CommonParsers, TimesParserCountOnly) {
	StringPtr text = "foooob";

	auto parser = sequence(exactly('f'), times(exactly('o'), 4));

	{
	Input input(text.begin(), text.begin() + 4);
	Maybe<Tuple<>> result = parser(input);
	EXPECT_TRUE(result == nullptr);
	EXPECT_TRUE(input.atEnd());
	}

	{
	Input input(text.begin(), text.begin() + 5);
	Maybe<Tuple<>> result = parser(input);
	EXPECT_TRUE(result != nullptr);
	EXPECT_TRUE(input.atEnd());
	}

	{
	Input input(text.begin(), text.end());
	Maybe<Tuple<>> result = parser(input);
	EXPECT_TRUE(result != nullptr);
	EXPECT_FALSE(input.atEnd());
	}

	text = "fooob";

	{
	Input input(text.begin(), text.end());
	Maybe<Tuple<>> result = parser(input);
	EXPECT_TRUE(result == nullptr);
	EXPECT_FALSE(input.atEnd());
	}
	}

	TEST(CommonParsers, ManyParserSubResult) {
	StringPtr text = "foooob";

	auto parser = many(any);

	{
	Input input(text.begin(), text.end());
	Maybe<Array<char>> result = parser(input);
	KJ_IF_MAYBE(chars, result) {
	EXPECT_EQ(text, heapString(*chars));
	} else {
	ADD_FAILURE() << "Expected char array, got null.";
	}
	EXPECT_TRUE(input.atEnd());
	}
	}

	TEST(CommonParsers, OptionalParser) {
	auto parser = sequence(
	transform(exactly('b'), []() -> uint { return 123; }),
	optional(transform(exactly('a'), []() -> uint { return 456; })),
	transform(exactly('r'), []() -> uint { return 789; }));

	{
	StringPtr text = "bar";
	Input input(text.begin(), text.end());
	Maybe<Tuple<uint, Maybe<uint>, uint>> result = parser(input);
	KJ_IF_MAYBE(value, result) {
	EXPECT_EQ(123u, get<0>(*value));
	KJ_IF_MAYBE(value2, get<1>(*value)) {
	EXPECT_EQ(456u, *value2);
	} else {
	ADD_FAILURE() << "Expected 456, got null.";
	}
	EXPECT_EQ(789u, get<2>(*value));
	} else {
	ADD_FAILURE() << "Expected result tuple, got null.";
	}
	EXPECT_TRUE(input.atEnd());
	}

	{
	StringPtr text = "br";
	Input input(text.begin(), text.end());
	Maybe<Tuple<uint, Maybe<uint>, uint>> result = parser(input);
	KJ_IF_MAYBE(value, result) {
	EXPECT_EQ(123u, get<0>(*value));
	EXPECT_TRUE(get<1>(*value) == nullptr);
	EXPECT_EQ(789u, get<2>(*value));
	} else {
	ADD_FAILURE() << "Expected result tuple, got null.";
	}
	EXPECT_TRUE(input.atEnd());
	}

	{
	StringPtr text = "bzr";
	Input input(text.begin(), text.end());
	Maybe<Tuple<uint, Maybe<uint>, uint>> result = parser(input);
	EXPECT_TRUE(result == nullptr);
	}
	}

	TEST(CommonParsers, OneOfParser) {
	auto parser = oneOf(
	transform(sequence(exactly('f'), exactly('o'), exactly('o')),
	[]() -> StringPtr { return "foo"; }),
	transform(sequence(exactly('b'), exactly('a'), exactly('r')),
	[]() -> StringPtr { return "bar"; }));

	{
	StringPtr text = "foo";
	Input input(text.begin(), text.end());
	Maybe<StringPtr> result = parser(input);
	KJ_IF_MAYBE(s, result) {
	EXPECT_EQ("foo", *s);
	} else {
	ADD_FAILURE() << "Expected 'foo', got null.";
	}
	EXPECT_TRUE(input.atEnd());
	}

	{
	StringPtr text = "bar";
	Input input(text.begin(), text.end());
	Maybe<StringPtr> result = parser(input);
	KJ_IF_MAYBE(s, result) {
	EXPECT_EQ("bar", *s);
	} else {
	ADD_FAILURE() << "Expected 'bar', got null.";
	}
	EXPECT_TRUE(input.atEnd());
	}
	}

	TEST(CommonParsers, TransformParser) {
	StringPtr text = "foo";

	auto parser = transformWithLocation(
	sequence(exactly('f'), exactly('o'), exactly('o')),
	[](Span<const char*> location) -> int {
	EXPECT_EQ("foo", StringPtr(location.begin(), location.end()));
	return 123;
	});

	{
	Input input(text.begin(), text.end());
	Maybe<int> result = parser(input);
	KJ_IF_MAYBE(i, result) {
	EXPECT_EQ(123, *i);
	} else {
	ADD_FAILURE() << "Expected 123, got null.";
	}
	EXPECT_TRUE(input.atEnd());
	}
	}

	TEST(CommonParsers, TransformOrRejectParser) {
	auto parser = transformOrReject(many(any),
	[](Array<char> chars) -> Maybe<int> {
	if (heapString(chars) == "foo") {
	return 123;
	} else {
	return nullptr;
	}
	});

	{
	StringPtr text = "foo";
	Input input(text.begin(), text.end());
	Maybe<int> result = parser(input);
	KJ_IF_MAYBE(i, result) {
	EXPECT_EQ(123, *i);
	} else {
	ADD_FAILURE() << "Expected 123, got null.";
	}
	EXPECT_TRUE(input.atEnd());
	}

	{
	StringPtr text = "bar";
	Input input(text.begin(), text.end());
	Maybe<int> result = parser(input);
	EXPECT_TRUE(result == nullptr);
	EXPECT_TRUE(input.atEnd());
	}
	}

	TEST(CommonParsers, References) {
	struct TransformFunc {
	int value;

	TransformFunc(int value): value(value) {}

	int operator()() const { return value; }
	};

	// Don't use auto for the parsers here in order to verify that the templates are properly choosing
	// whether to use references or copies.

	Transform_<Exactly_<char>, TransformFunc> parser1 =
	transform(exactly('f'), TransformFunc(12));

	auto otherParser = exactly('o');
	Transform_<Exactly_<char>&, TransformFunc> parser2 =
	transform(otherParser, TransformFunc(34));

	auto otherParser2 = exactly('b');
	Transform_<Exactly_<char>, TransformFunc> parser3 =
	transform(mv(otherParser2), TransformFunc(56));

	StringPtr text = "foob";
	auto parser = transform(
	sequence(parser1, parser2, exactly('o'), parser3),
	[](int i, int j, int k) { return i + j + k; });

	{
	Input input(text.begin(), text.end());
	Maybe<int> result = parser(input);
	KJ_IF_MAYBE(i, result) {
	EXPECT_EQ(12 + 34 + 56, *i);
	} else {
	ADD_FAILURE() << "Expected 12 + 34 + 56, got null.";
	}
	EXPECT_TRUE(input.atEnd());
	}
	}

	TEST(CommonParsers, NotLookingAt) {
	auto parser = notLookingAt(exactly('a'));

	{
	StringPtr text = "a";
	Input input(text.begin(), text.end());
	EXPECT_TRUE(parser(input) == nullptr);
	EXPECT_FALSE(input.atEnd());
	}

	{
	StringPtr text = "b";
	Input input(text.begin(), text.end());
	EXPECT_TRUE(parser(input) != nullptr);
	EXPECT_FALSE(input.atEnd());
	}
	}

	TEST(CommonParsers, EndOfInput) {
	auto parser = endOfInput;

	{
	StringPtr text = "a";
	Input input(text.begin(), text.end());
	EXPECT_TRUE(parser(input) == nullptr);
	EXPECT_TRUE(parser(input) == nullptr);
	input.next();
	EXPECT_FALSE(parser(input) == nullptr);
	}
	}

	} // namespace
	} // namespace parse
	} // namespace kj