public TestItem(FieldList fieldList, string itemName = "dummy")
            : base(new ID(new Guid()), 
                   new ItemData(new ItemDefinition(new ID(new Guid()), itemName, new ID(new Guid()), new ID(new Guid())), Language.Invariant, new Sitecore.Data.Version(1), fieldList),
                     TestDatabaseFactory.Create())

        {
        }

		public ColumnInfo( ObjectMap objectMap, string[] columnNames )
		{
			this.columnNames = columnNames;
			columnComboHashCode = ObjectConstructor.GetFieldComboHashCode( columnNames );
			fields = new FieldList();
			for( int i = 0; i < columnNames.Length; i++ )
			{
				string columnName = columnNames[ i ];
				FieldMap fm = objectMap.GetFieldMapFromColumn( columnName );
				if( fm == null )
				{
					// check for column names with table name prefixes
					int pos = columnName.IndexOf( '.' );
					if( pos > 0 )
					{
						columnName = columnName.Substring( pos + 1, columnName.Length - pos - 1 );
						fm = objectMap.GetFieldMapFromColumn( columnName );
						if( fm != null )
						{
							columnNames[ i ] = columnName;
						}
					}
					if( fm == null ) // no corresponding member could be found - assume column is calculated
					{
						columnCalculatedMask |= 1 << i;
					}
				}
				fields.Add( fm ); // intentionally add null entries to preserve column order 
			}
		}

 public void CreateItemWithShowInMenuFalseShouldReturnEmptyString()
 {
     FieldList stubFieldList = new FieldList();
     Item stub = new ContentItem(stubFieldList);
     string navigationTitle = ResultFactory.Create(stub);
     Assert.IsNotNull(navigationTitle);
 }

 public void CreateItemWithShowInMenuTrueShouldReturnItemNavigationTitle()
 {
     FieldList stubFieldList = new FieldList();
     Item stub = new ContentItem(stubFieldList);
     string navigationTitle = ResultFactory.Create(stub);
     Assert.AreEqual("NavigationTitle", navigationTitle);
 }

        public void WhenReferencedProcessIsVersioningEnabled_VerionDateAndVersionNumberFieldsShouldBeAdded_CR()
        {
            // Arrange.
            var done = false;

            var fieldList = new FieldList { IsVersioningEnabled = true };
            var vm = CreateReverseCrossRefDisplayFieldViewModel();

            Mock.Arrange(() => FieldList.BeginGetCrossReferenceSubfields(ReferencedProcessName, FieldName, Arg.IsAny<EventHandler<DataPortalResult<FieldList>>>()))
                .DoInstead<string, string, EventHandler<DataPortalResult<FieldList>>>((process, field, action) => action(null, new DataPortalResult<FieldList>(fieldList, null, null)));

            // Act.
            vm.LoadSubFields(() => { done = true; });

            // Assert.
            EnqueueConditional(() => done);
            EnqueueCallback(
                () =>
                    {
                        Assert.IsTrue(vm.Subfields.Any(f => f.SystemName == Constants.VersionNumber));
                        Assert.IsTrue(vm.Subfields.Any(f => f.SystemName == Constants.VersionDate));
                    });

            EnqueueTestComplete();
        }

 public FieldList(Position pos, Symbol name, Symbol type, FieldList tail)
 {
     Pos = pos;
     Name = name;
     Type = type;
     Tail = tail;
 }

 public static BoolList BuildFromFieldList(FieldList param)
 {
     if (param == null)
         return null;
     else
         return new BoolList(param.Escape, BuildFromFieldList(param.Tail));
 }

        public void ProcessShouldSetAreaControllerRendererIfDescendantOfAreaControllerTemplate()
        {
            // Arrange
            var builder = new Template.Builder("Area Controller Template", Constants.Templates.AreaController, new TemplateCollection());
            var fieldList = new FieldList
                {
                    {Constants.Fields.Controller.Action, "Index"},
                    {Constants.Fields.Controller.Name, "HelloWorld"},
                    {Constants.Fields.Controller.Area, "MyArea"},
                    {Constants.Fields.Controller.UseChildActionBehavior, "1"}
                };
            var innerItem = new TestItem(fieldList);

            var rendering = new Rendering { RenderingItem = new RenderingItem(innerItem)};
            _args.Rendering = rendering;
            _args.RenderingTemplate = builder.Template;

            _controller.ControllerRunner = new Mock<IControllerRunner>().Object;

            // Act
            _controller.Process(_args);

            // Assert
            Assert.That(_args.Result, Is.InstanceOf<AreaControllerRenderer>(), "Rendering should be an AreaControllerRenderer");
        }

 public void FakeItemAddFieldShouldReturnField(FieldList fieldList,string fieldValue)
 {
     var fieldId = ID.NewID;
     fieldList.Add(fieldId,fieldValue);
     var fake = new FakeItem(fieldList);
     fake[fieldId].ShouldBeEquivalentTo(fieldValue);
 }

        public virtual void Process(GetItemFieldsArgs args)
        {
            Assert.ArgumentNotNull(args, "args");
            Assert.ArgumentNotNull(args.ItemDefinition, "args.ItemDefinition");
            Assert.ArgumentNotNull(args.Context, "args.Context");

            var itemId = args.ItemDefinition.ID;
            var fields = new FieldList();
            var owner = typeof(ContactFacetDataProvider).Name;
            fields.Add(Sitecore.FieldIDs.CreatedBy, owner);
            fields.Add(Sitecore.FieldIDs.Owner, owner);
            if (IDTableHelper.IsFacetItem(itemId))
            {
                var facetName = IDTableHelper.GetFacetName(itemId);
                fields.Add(Sitecore.FieldIDs.DisplayName, facetName);
                fields.Add(Sitecore.Strategy.Contacts.DataProviders.FieldIDs.ContactFacetName, facetName);
                var contractType = ContactFacetHelper.GetContractTypeForFacet(facetName);
                if (contractType != null)
                {
                    fields.Add(Sitecore.Strategy.Contacts.DataProviders.FieldIDs.ContactFacetContract, contractType.AssemblyQualifiedName);
                    if (ContactFacetHelper.ContactFacetImplementations.ContainsKey(contractType))
                    {
                        var implType = ContactFacetHelper.ContactFacetImplementations[contractType];
                        if (implType != null)
                        {
                            fields.Add(Sitecore.Strategy.Contacts.DataProviders.FieldIDs.ContactFacetImplementation, implType.AssemblyQualifiedName);
                        }
                    }
                }
            }
            if (IDTableHelper.IsFacetMemberItem(itemId))
            {
                var memberName = IDTableHelper.GetFacetMemberName(itemId);
                fields.Add(Sitecore.FieldIDs.DisplayName, memberName);
                fields.Add(Sitecore.Strategy.Contacts.DataProviders.FieldIDs.ContactFacetMemberName, memberName);
                var facetId = IDTableHelper.GetFacetMemberParentId(itemId);
                var facetName = IDTableHelper.GetFacetName(facetId);
                var memberType = ContactFacetHelper.GetFacetMemberType(facetName, memberName);
                if (memberType != null)
                {
                    fields.Add(Sitecore.Strategy.Contacts.DataProviders.FieldIDs.ContactFacetMemberType, memberType.AssemblyQualifiedName);
                }
            }
            if (IDTableHelper.IsFacetMemberValueItem(itemId))
            {
                var value = IDTableHelper.GetFacetMemberValue(itemId);
                if (!string.IsNullOrEmpty(value))
                {
                    fields.Add(Sitecore.Strategy.Contacts.DataProviders.FieldIDs.ContactFacetMemberValueValue, value);
                }
                var description = IDTableHelper.GetFacetMemberValueDescription(itemId);
                if (!string.IsNullOrEmpty(description))
                {
                    fields.Add(Sitecore.FieldIDs.DisplayName, description);
                    fields.Add(Sitecore.Strategy.Contacts.DataProviders.FieldIDs.ContactFacetMemberValueDescription, description);
                }
            }
            args.FieldList = fields;
        }

 public FakeItem(FieldList fieldList, ID itemid, ID templateId, string itemName = DefaultitemName, string databaseName = DefaultDatabaseName)
     : base(itemid,
         new ItemData(new ItemDefinition(ID.NewID, itemName, templateId, ID.NewID),
                      Globalization.Language.Invariant, new Data.Version(1), fieldList),
         new Database(databaseName))
 {
     FakeChildren = new ItemList();
 }

 public Resolve(string name, params string[] shows)
 {
     Name = name;
     Show = new FieldList();
     foreach (var show in shows) {
         Show.Add(show);
     }
 }

        public void FakeItemGetFieldFromIdShoudlReturnFieldValue(string fieldValue, FieldList fieldList)
        {
            var fieldId = ID.NewID;

            fieldList.Add(fieldId, fieldValue);
            var fake = new FakeItem(fieldList);

            fake[fieldId].ShouldAllBeEquivalentTo(fieldValue);
        }

 public FunctionDeclaration(Position pos, Symbol name, FieldList param, NameType result, Expression body, FunctionDeclaration next)
 {
     Pos = pos;
     Name = name;
     Param = param;
     Result = result;
     Body = body;
     Next = next;
 }

        public void FakeItemAddMultipleFieldShouldReturnField(FieldList fieldList, string fieldValue)
        {
            var fieldIdOne = ID.NewID;
            var fieldIdTwo = ID.NewID;
            fieldList.Add(fieldIdOne, fieldValue);
            fieldList.Add(fieldIdTwo, fieldValue);
            var fake = new FakeItem(fieldList);

            fake.Fields.Should().HaveCount(2);
        }

 public DataRequest()
 {
     Verb = "get";
     Start = -1;
     Limit = 0;
     Parameters = new ParameterList();
     Resolves = new ResolveList();
     Joins = new List<Join>();
     Show = new FieldList();
     Hide = new FieldList();
     Sort = new FieldList();
 }

    public static Item CreateInstance(string itemName, ID itemId, ID templateId, FieldList fields, Database database, Language language, Version version)
    {
      Assert.ArgumentNotNullOrEmpty(itemName, "itemName");
      Assert.ArgumentNotNull(itemId, "itemId");
      Assert.ArgumentNotNull(templateId, "templateId");
      Assert.ArgumentNotNull(fields, "fields");
      Assert.ArgumentNotNull(database, "database");
      Assert.ArgumentNotNull(language, "language");
      Assert.ArgumentNotNull(version, "version");

      return new ItemWrapper(itemId, new ItemData(new ItemDefinition(itemId, itemName, templateId, ID.Null), language, version, fields), database);
    }

 public static void AddRow(FieldList fields, StringBuilder sb, Dictionary<String, String> dic)
 {
     for (int i = 0; i < fields.Count; i++)
     {
         Field f = fields[i];
         f.AppendValueTo(sb, dic);
         if ((i + 1) < fields.Count)
         {
             sb.Append(";");
         }
     }
     sb.AppendLine("");
 }

        public void ItemTest()
        {
            var demo =  new Demo();

            var fieldId = demo.FieldName;
            const string fieldValue = "demoText";
            var stubList = new FieldList {{fieldId, fieldValue}};
            var fakeItem = new FakeItem(stubList);

            var item = fakeItem;

            demo.GetField(item).ShouldAllBeEquivalentTo(fieldValue);
        }

 public static void MakeHeader(FieldList fields, StringBuilder sb)
 {
     for (int i = 0; i < fields.Count; i++)
     {
         Field f = fields[i];
         f.RenderTo(sb, f.Title, ";");
         if ((i + 1) < fields.Count)
         {
             sb.Append(";");
         }
     }
     sb.AppendLine("");
 }