public void Constructor_PassValidArguments_CopyValues()
		{
			using (ConnectionBase connection = new ConnectionMock())
			{
				string[] documents = new string[] { "doc 1", "doc 2", "doc 3" };
				string[] keywords = new string[] { "keyword1", "keyword2" };
				string index = "test";

				BuildExcerptsCommand target = new BuildExcerptsCommand(connection, documents, keywords, index);

				target.Documents.Should().Have.SameValuesAs(documents);
				target.Keywords.Should().Have.SameValuesAs(keywords);
				target.Index.Should().Be.EqualTo(index);
			}
		}
		public void DeserializeResponseTest()
		{
			using (ConnectionMock connection = new ConnectionMock("test"))
			{
				bool deserializeCalled = false;
				BuildExcerptsCommand target = new BuildExcerptsCommand(connection);
				var accessor = GetCommandAccessor(target);
				IBinaryReader arrayReader = new ArrayListReaderMock(new ArrayList());
				accessor.Result = new MBuildExcerptsCommandResult
              	{
              		DeserializeIBinaryReaderInt32 = (reader, count) => { deserializeCalled = (reader == arrayReader && count == 1); }
              	};
				target.Documents.Add("test");

				accessor.DeserializeResponse(arrayReader);

				Assert.IsTrue(deserializeCalled);
			}
		}
		public void SerializeRequestTest()
		{
			using (ConnectionMock connection = new ConnectionMock("test"))
			{
				BuildExcerptsCommand target = new BuildExcerptsCommand(connection);
				var accessor = GetCommandAccessor(target);
				ArrayList values = new ArrayList();

				IBinaryWriter writer = new ArrayListWriterMock(values);
				accessor.SerializeRequest(writer);

				Assert.AreEqual(values.Count, 15);
				Assert.AreEqual(values[0], BuildExcerptsCommand_Accessor.MODE);
				Assert.AreEqual(values[1], (int)target.Options);
				Assert.AreEqual(values[2], target.Index);
				// Keywords skipped, will be tested in unit-test for StringList class
				Assert.AreEqual(values[4], target.BeforeMatch);
				Assert.AreEqual(values[5], target.AfterMatch);
				Assert.AreEqual(values[6], target.SnippetsDelimiter);
				Assert.AreEqual(values[7], target.SnippetSizeLimit);
				Assert.AreEqual(values[8], target.WordsAroundKeyword);
				Assert.AreEqual(values[9], target.SnippetsCountLimit);
				Assert.AreEqual(values[10], target.WordsCountLimit);
				Assert.AreEqual(values[11], target.StartPassageId);
				Assert.AreEqual(values[12], target.HtmlStripMode.ToString().ToLowerInvariant());
				Assert.AreEqual(values[13], target.PassageBoundary.ToString().ToLowerInvariant());
				// Documents skipped, for same reason
			}
		}
		public void ExecuteTest_EmptyIndex_ThrowsException()
		{
			using (ConnectionMock connection = new ConnectionMock("test"))
			{
				connection.SkipHandshake = true;
				connection.SkipDeserializeCommand = true;
				connection.SkipSerializeCommand = true;

				BuildExcerptsCommand target = new BuildExcerptsCommand(connection);
				target.Documents.Add("test doc content");
				target.Keywords.Add("test");
				Executing.This(target.Execute).Should().Throw<ArgumentException>();

				target.Index = "test";
				Executing.This(target.Execute).Should().NotThrow();
			}
		}
		public void CommandInfoTest()
		{
			using (ConnectionMock connection = new ConnectionMock("test"))
			{
				BuildExcerptsCommand target = new BuildExcerptsCommand(connection);
				BuildExcerptsCommand_Accessor accessor = GetCommandAccessor(target);
				Assert.IsNotNull(accessor.CommandInfo);
				Assert.AreEqual(accessor.CommandInfo.Id, ServerCommand.Excerpt);
				Assert.AreEqual(accessor.CommandInfo.Version, BuildExcerptsCommand_Accessor.COMMAND_VERSION);
			}
		} 
		public void DocumentsTest()
		{
			using (ConnectionMock connection = new ConnectionMock("test"))
			{
				BuildExcerptsCommand target = new BuildExcerptsCommand(connection);
				Assert.IsNotNull(target.Documents);
				Assert.IsInstanceOfType(target.Documents, typeof (IList<string>));
			}
		}
		public void IndexTest()
		{
			using (ConnectionBase connection = new ConnectionMock())
			{
				BuildExcerptsCommand target = new BuildExcerptsCommand(connection);
				// default value
				Assert.AreEqual(target.Index, null);
				// valid value
				string expected = "test";
				target.Index = expected;
				Assert.AreEqual(expected, target.Index);
				// invalid value
				target.Index = null;
			}
		}
		public void WordsAroundKeywordTest()
		{
			using (ConnectionBase connection = new ConnectionMock())
			{
				BuildExcerptsCommand target = new BuildExcerptsCommand(connection);
				// default value
				Assert.AreEqual(target.WordsAroundKeyword, BuildExcerptsCommand_Accessor.DEFAULT_WORDS_AROUND_KEYWORD);
				// valid value
				int expected = 0;
				target.WordsAroundKeyword = expected;
				Assert.AreEqual(expected, target.WordsAroundKeyword);
				// invalid value
				target.WordsAroundKeyword = -1;
			}
		}
		public void PassageBoundaryTest()
		{
			using (ConnectionBase connection = new ConnectionMock())
			{
				BuildExcerptsCommand target = new BuildExcerptsCommand(connection);
				// default value
				Assert.AreEqual(target.PassageBoundary, BuildExcerptsCommand_Accessor.DEFAULT_PASSAGE_BOUNDARY);
				// valid value
				PassageBoundary expected = PassageBoundary.Paragraph;
				target.PassageBoundary = expected;
				Assert.AreEqual(expected, target.PassageBoundary);
			}
		}
		public void HtmlStripModeTest()
		{
			using (ConnectionBase connection = new ConnectionMock())
			{
				BuildExcerptsCommand target = new BuildExcerptsCommand(connection);
				// default value
				Assert.AreEqual(target.HtmlStripMode, BuildExcerptsCommand_Accessor.DEFAULT_HTML_STRIP_MODE);
				// valid value
				HtmlStripMode expected = HtmlStripMode.Retain;
				target.HtmlStripMode = expected;
				Assert.AreEqual(expected, target.HtmlStripMode);
			}
		}
		public void StartPassageIdTest()
		{
			using (ConnectionBase connection = new ConnectionMock())
			{
				BuildExcerptsCommand target = new BuildExcerptsCommand(connection);
				// default value
				Assert.AreEqual(target.StartPassageId, BuildExcerptsCommand_Accessor.DEFAULT_START_PASSAGE_ID);
				// valid value
				int expected = 1;
				target.StartPassageId = expected;
				Assert.AreEqual(expected, target.StartPassageId);
				// valid value
				target.StartPassageId = -1;
			}
		}
		public void WordsCountLimitTest()
		{
			using (ConnectionBase connection = new ConnectionMock())
			{
				BuildExcerptsCommand target = new BuildExcerptsCommand(connection);
				// default value
				Assert.AreEqual(target.WordsCountLimit, BuildExcerptsCommand_Accessor.DEFAULT_WORDS_COUNT_LIMIT);
				// valid value
				int expected = 1;
				target.WordsCountLimit = expected;
				Assert.AreEqual(expected, target.WordsCountLimit);
				// invalid value
				target.WordsCountLimit = -1;
			}
		}
		public void SnippetsDelimiterTest()
		{
			using (ConnectionBase connection = new ConnectionMock())
			{
				BuildExcerptsCommand target = new BuildExcerptsCommand(connection);
				// default value
				Assert.AreEqual(target.SnippetsDelimiter, BuildExcerptsCommand_Accessor.DEFAULT_SNIPPETS_DELIMITER);
				// valid value
				string expected = String.Empty;
				target.SnippetsDelimiter = expected;
				Assert.AreEqual(expected, target.SnippetsDelimiter);
				// invalid value
				target.SnippetsDelimiter = null;
			}
		}
		public void SnippetSizeLimitTest()
		{
			using (ConnectionBase connection = new ConnectionMock())
			{
				BuildExcerptsCommand target = new BuildExcerptsCommand(connection);
				// default value
				Assert.AreEqual(target.SnippetSizeLimit, BuildExcerptsCommand_Accessor.DEFAULT_SNIPPET_SIZE_LIMIT);
				// valid value
				int expected = 1;
				target.SnippetSizeLimit = expected;
				Assert.AreEqual(expected, target.SnippetSizeLimit);
				// invalid value
				target.SnippetSizeLimit = 0;
			}
		}
		public void OptionsTest()
		{
			using (ConnectionBase connection = new ConnectionMock())
			{
				BuildExcerptsCommand target = new BuildExcerptsCommand(connection);
				// default value
				Assert.AreEqual(target.Options, BuildExcerptsCommand_Accessor.DEFAULT_OPTIONS);
				// valid value
				BuildExcerptsOptions expected = BuildExcerptsOptions.OrderByWeight;
				target.Options = expected;
				Assert.AreEqual(expected, target.Options);
			}
		}
		public void BeforeMatchTest()
		{
			using (ConnectionBase connection = new ConnectionMock())
			{
				BuildExcerptsCommand target = new BuildExcerptsCommand(connection);
				// default value
				Assert.AreEqual(target.BeforeMatch, BuildExcerptsCommand_Accessor.DEFAULT_BEFORE_MATCH);
				// valid value
				string expected = "<pre>";
				target.BeforeMatch = expected;

				target.BeforeMatch.Should().Be.EqualTo(expected);
				// invalid value
				target.BeforeMatch = null;
			}
		}
		public void AfterMatchTest()
		{
			using (ConnectionBase connection = new ConnectionMock())
			{
				BuildExcerptsCommand target = new BuildExcerptsCommand(connection);
				// default value
				Assert.AreEqual(target.AfterMatch, BuildExcerptsCommand_Accessor.DEFAULT_AFTER_MATCH);
				// valid value
				string expected = "</pre>";
				target.AfterMatch = expected;
				string actual = target.AfterMatch;
				Assert.AreEqual(expected, actual);
				// invalid value
				target.AfterMatch = null;
			}
		}