C# LiftExportAsFragmentTestSession.CreateItem方法代码示例

		public void FlagOnEntry_OutputAsTrait()
		{
			using (var session = new LiftExportAsFragmentTestSession())
			{
				LexEntry entry = session.CreateItem();

				entry.SetFlag("ATestFlag");
				//_lexEntryRepository.SaveItem(entry);
				session.LiftWriter.Add(entry);
				session.LiftWriter.End();
				AssertHasAtLeastOneMatch("entry/trait[@name='ATestFlag' and @value]", session);
			}
		}

		public void EntryHasDateCreated()
		{
			using (var session = new LiftExportAsFragmentTestSession())
			{
				LexEntry entry = session.CreateItem();
				session.LiftWriter.Add(entry);
				session.LiftWriter.End();
				string result = session.StringBuilder.ToString();
				AssertThatXmlIn.String(result).HasAtLeastOneMatchForXpath(
					String.Format("//entry[@dateCreated=\"{0}\"]", entry.CreationTime.ToString("yyyy-MM-ddTHH:mm:ssZ"))
				);
			}
		}

		public void Add_CultureUsesPeriodForTimeSeparator_DateAttributesOutputWithColon()
		{
			var culture = new CultureInfo("en-US");
			culture.DateTimeFormat.TimeSeparator = ".";

			Thread.CurrentThread.CurrentCulture = culture;

			using (var session = new LiftExportAsFragmentTestSession())
			{
				LexEntry entry = session.CreateItem();
				entry.LexicalForm["test"] = "lexicalForm";
				// make dateModified different than dateCreated
				//_lexEntryRepository.SaveItem(entry);
				session.LiftWriter.Add(entry);
				session.LiftWriter.End();
				string result = session.StringBuilder.ToString();
				AssertThatXmlIn.String(result).HasAtLeastOneMatchForXpath(
					String.Format("//entry[@dateModified=\"{0}\"]",
								  entry.ModificationTime.ToString("yyyy-MM-ddTHH:mm:ssZ", CultureInfo.InvariantCulture))
					);
				Assert.IsTrue(result.Contains(":"), "should contain colons");
				Assert.IsFalse(result.Contains("."), "should not contain periods");
			}
		}

		public void Entry_HasId_RemembersId()
		{
			using (var session = new LiftExportAsFragmentTestSession())
			{
				LexEntry entry = session.CreateItem();
				entry.Id = "my id";
				//_lexEntryRepository.SaveItem(entry);
				session.LiftWriter.Add(entry);
				session.LiftWriter.End();
				string result = session.StringBuilder.ToString();
				AssertThatXmlIn.String(result).HasAtLeastOneMatchForXpath("//entry[@id='my id']");
			}
		}

		public void EntryGuid()
		{
			using (var session = new LiftExportAsFragmentTestSession())
			{
				LexEntry entry = session.CreateItem();
				session.LiftWriter.Add(entry);
				session.LiftWriter.End();
				string result = session.StringBuilder.ToString();
				AssertThatXmlIn.String(result).HasAtLeastOneMatchForXpath(String.Format("//entry[@guid=\"{0}\"]", entry.Guid));
			}
		}

		public void CustomOptionRefOnEntry()
		{
			using (var session = new LiftExportAsFragmentTestSession())
			{
				//_fieldToOptionListName.Add("flub", "kindsOfFlubs");
				LexEntry entry = session.CreateItem();

				var o = entry.GetOrCreateProperty<OptionRef>("flub");
				o.Value = "orange";
				//_lexEntryRepository.SaveItem(entry);
				session.LiftWriter.Add(entry);
				session.LiftWriter.End();
				AssertHasAtLeastOneMatch(
					"entry/trait[@name='flub' and @value='orange']",
					session
				);
			}
		}

		public void Entry_EntryHasIdWithInvalidXMLCharacters_CharactersEscaped()
		{
			const string expected = "id=\"<>&"'\"";
			using (var session = new LiftExportAsFragmentTestSession())
			{
				var entry = session.CreateItem();
				// technically the only invalid characters in an attribute are & < and " (when surrounded by ")
				entry.Id = "<>&\"\'";
				//_lexEntryRepository.SaveItem(entry);
				session.LiftWriter.Add(entry);
				string result = session.OutputString();
				Assert.IsTrue(result.Contains(expected));
			}
		}

		public void NoteOnEntry_OutputAsNote()
		{
			using (var session = new LiftExportAsFragmentTestSession())
			{
				LexEntry entry = session.CreateItem();

				MultiText m =
					entry.GetOrCreateProperty<MultiText>(PalasoDataObject.WellKnownProperties.Note);
				m["zz"] = "orange";
				//_lexEntryRepository.SaveItem(entry);
				session.LiftWriter.Add(entry);
				session.LiftWriter.End();
				AssertHasAtLeastOneMatch("entry/note/form[@lang='zz' and text='orange']", session);
				AssertHasAtLeastOneMatch("entry[not(field)]", session);
			}
		}

		public void SensesAreLastObjectsInEntry() // this helps conversions to sfm review: It would be great if this wasn't necessary CP 2011-01
		{
			using (var session = new LiftExportAsFragmentTestSession())
			{
				LexEntry entry = session.CreateItem();

				entry.LexicalForm["blue"] = "ocean";

				LexSense sense1 = new LexSense();
				sense1.Gloss["a"] = "aaa";
				entry.Senses.Add(sense1);
				LexSense sense2 = new LexSense();
				sense2.Gloss["b"] = "bbb";
				entry.Senses.Add(sense2);

				MultiText citation =
					entry.GetOrCreateProperty<MultiText>(LexEntry.WellKnownProperties.Citation);
				citation["zz"] = "orange";

				MultiText note =
					entry.GetOrCreateProperty<MultiText>(PalasoDataObject.WellKnownProperties.Note);
				note["zz"] = "orange";

				MultiText field = entry.GetOrCreateProperty<MultiText>("custom");
				field["zz"] = "orange";

				//_lexEntryRepository.SaveItem(entry);
				session.LiftWriter.Add(entry);
				session.LiftWriter.End();
				string result = session.StringBuilder.ToString();
				AssertThatXmlIn.String(result).HasAtLeastOneMatchForXpath("//gloss[@lang='a']/text[text()='aaa']");
				AssertThatXmlIn.String(result).HasAtLeastOneMatchForXpath("//gloss[@lang='b']/text[text()='bbb']");
				AssertThatXmlIn.String(result).HasNoMatchForXpath("/entry/sense[2]/following-sibling::*");
			}
		}

		public void LexicalUnit()
		{
			using (var session = new LiftExportAsFragmentTestSession())
			{
				LexEntry e = session.CreateItem();
				e.LexicalForm.SetAlternative("x", "orange");
				//_lexEntryRepository.SaveItem(e);
				session.LiftWriter.Add(e);
				session.LiftWriter.End();
				AssertHasAtLeastOneMatch("entry/lexical-unit/form[@lang='x']/text[text()='orange']", session);
				AssertHasAtLeastOneMatch("entry/lexical-unit/form[@lang='x'][not(trait)]", session);
			}
		}

		public void LexicalUnitWithStarredForm()
		{
			using (var session = new LiftExportAsFragmentTestSession())
			{
				LexEntry e = session.CreateItem();

				e.LexicalForm.SetAlternative("x", "orange");
				e.LexicalForm.SetAnnotationOfAlternativeIsStarred("x", true);
				//_lexEntryRepository.SaveItem(e);
				session.LiftWriter.Add(e);
				session.LiftWriter.End();

				AssertHasAtLeastOneMatch(
					"entry/lexical-unit/form[@lang='x']/annotation[@name='flag' and @value='1']",
					session
				);
			}
		}

		public void LexEntry_becomes_entry()
		{
			using (var session = new LiftExportAsFragmentTestSession())
			{
				LexEntry entry = session.CreateItem();
				session.LiftWriter.Add(entry);
				session.LiftWriter.End();

				Assert.IsTrue(session.StringBuilder.ToString().StartsWith("<entry"));
			}
		}

		public void LexemeForm_SingleWritingSystem()
		{
			using (var session = new LiftExportAsFragmentTestSession())
			{
				LexEntry e = session.CreateItem();
				e.LexicalForm["xx"] = "foo";
				//_lexEntryRepository.SaveItem(e);
				session.LiftWriter.Add(e);
				session.LiftWriter.End();

				AssertHasAtLeastOneMatch("//lexical-unit/form[@lang='xx']", session);
			}
		}

		public void GetHumanReadableId_EntryHasId_GivesId()
		{
			using (var session = new LiftExportAsFragmentTestSession())
			{
				LexEntry entry = session.CreateItem();
				entry.Id = "my id";
				//_lexEntryRepository.SaveItem(entry);
				Assert.AreEqual(
					"my id",
					LiftWriter.GetHumanReadableIdWithAnyIllegalUnicodeEscaped(entry, new Dictionary<string, int>())
				);
			}
		}

		public void CustomMultiTextOnEntry()
		{
			using (var session = new LiftExportAsFragmentTestSession())
			{
				var entry = session.CreateItem();

				var m = entry.GetOrCreateProperty<MultiText>("flubadub");
				m["zz"] = "orange";
				//_lexEntryRepository.SaveItem(entry);
				session.LiftWriter.Add(entry);
				session.LiftWriter.End();
				AssertHasAtLeastOneMatch("entry/field[@type='flubadub']/form[@lang='zz' and text='orange']", session);
			}
		}