Top 10 Longest Uncovered Source Code Blocks

      }

    }

    public void DeserializeObject()

    {

      string json = JsonConvert.SerializeObject(new List<Employee>

        {

          new Employee

            {

              BirthDate = new DateTime(1977, 12, 30, 1, 1, 1, DateTimeKind.Utc),

              FirstName = "Maurice",

              LastName = "Moss",

              Department = "IT",

              JobTitle = "Support"

            },

          new Employee

            {

              BirthDate = new DateTime(1978, 3, 15, 1, 1, 1, DateTimeKind.Utc),

              FirstName = "Jen",

              LastName = "Barber",

              Department = "IT",

              JobTitle = "Manager"

            }

        }, Formatting.Indented);

      //[

      //  {

      //    "FirstName": "Maurice",

      //    "LastName": "Moss",

      //    "BirthDate": "\/Date(252291661000)\/",

      //    "Department": "IT",

      //    "JobTitle": "Support"

      //  },

      //  {

      //    "FirstName": "Jen",

      //    "LastName": "Barber",

      //    "BirthDate": "\/Date(258771661000)\/",

      //    "Department": "IT",

      //    "JobTitle": "Manager"

      //  }

      //]

      List<IPerson> people = JsonConvert.DeserializeObject<List<IPerson>>(json, new PersonConverter());

      IPerson person = people[0];

      Console.WriteLine(person.GetType());

      // Newtonsoft.Json.Tests.Employee

      Console.WriteLine(person.FirstName);

      // Maurice

      Employee employee = (Employee)person;

      Console.WriteLine(employee.JobTitle);

      // Support

    }

    public class MyClass

    {

      public string Value { get; set; }

      return o => call(null, o);

    }

    public static bool CanConvertType(Type initialType, Type targetType, bool allowTypeNameToString)

    {

      ValidationUtils.ArgumentNotNull(initialType, "initialType");

      ValidationUtils.ArgumentNotNull(targetType, "targetType");

      if (ReflectionUtils.IsNullableType(targetType))

        targetType = Nullable.GetUnderlyingType(targetType);

      if (targetType == initialType)

        return true;

      if (typeof(IConvertible).IsAssignableFrom(initialType) && typeof(IConvertible).IsAssignableFrom(targetType))

      {

        return true;

      }

#if !PocketPC && !NET20

      if (initialType == typeof(DateTime) && targetType == typeof(DateTimeOffset))

        return true;

#endif

      if (initialType == typeof(Guid) && (targetType == typeof(Guid) || targetType == typeof(string)))

        return true;

      if (initialType == typeof(Type) && targetType == typeof(string))

        return true;

#if !PocketPC

      // see if source or target types have a TypeConverter that converts between the two

      TypeConverter toConverter = GetConverter(initialType);

      if (toConverter != null && !IsComponentConverter(toConverter) && toConverter.CanConvertTo(targetType))

      {

        if (allowTypeNameToString || toConverter.GetType() != typeof(TypeConverter))

          return true;

      }

      TypeConverter fromConverter = GetConverter(targetType);

      if (fromConverter != null && !IsComponentConverter(fromConverter) && fromConverter.CanConvertFrom(initialType))

        return true;

#endif

      // handle DBNull and INullable

      if (initialType == typeof(DBNull))

      {

        if (ReflectionUtils.IsNullable(targetType))

          return true;

      }

      return false;

    }

    private static bool IsComponentConverter(TypeConverter converter)

    {

#if !SILVERLIGHT && !PocketPC

      Console.WriteLine(javascriptJson);

    }

    public void GenericListAndDictionaryInterfaceProperties()

    {

      GenericListAndDictionaryInterfaceProperties o = new GenericListAndDictionaryInterfaceProperties();

      o.IDictionaryProperty = new Dictionary<string, int>

                                {

                                  {"one", 1},

                                  {"two", 2},

                                  {"three", 3}

                                };

      o.IListProperty = new List<int>

                          {

                            1, 2, 3

                          };

      o.IEnumerableProperty = new List<int>

                                {

                                  4, 5, 6

                                };

      string json = JsonConvert.SerializeObject(o, Formatting.Indented);

      Assert.AreEqual(@"{

  ""IEnumerableProperty"": [

    4,

    5,

    6

  ],

  ""IListProperty"": [

    1,

    2,

    3

  ],

  ""IDictionaryProperty"": {

    ""one"": 1,

    ""two"": 2,

    ""three"": 3

  }

}", json);

      GenericListAndDictionaryInterfaceProperties deserializedObject = JsonConvert.DeserializeObject<GenericListAndDictionaryInterfaceProperties>(json);

      Assert.IsNotNull(deserializedObject);

      CollectionAssert.AreEqual(o.IListProperty.ToArray(), deserializedObject.IListProperty.ToArray());

      CollectionAssert.AreEqual(o.IEnumerableProperty.ToArray(), deserializedObject.IEnumerableProperty.ToArray());

      CollectionAssert.AreEqual(o.IDictionaryProperty.ToArray(), deserializedObject.IDictionaryProperty.ToArray());

    }

    [Test]

    public void DeserializeBestMatchPropertyCase()

    {

    /// <param name="end">The end index.</param>

    /// <param name="step">The step.</param>

    /// <returns>A slice of the list.</returns>

    public static IList<T> Slice<T>(IList<T> list, int? start, int? end, int? step)

    {

      if (list == null)

        throw new ArgumentNullException("list");

      if (step == 0)

        throw new ArgumentException("Step cannot be zero.", "step");

      List<T> slicedList = new List<T>();

      // nothing to slice

      if (list.Count == 0)

        return slicedList;

      // set defaults for null arguments

      int s = step ?? 1;

      int startIndex = start ?? 0;

      int endIndex = end ?? list.Count;

      // start from the end of the list if start is negitive

      startIndex = (startIndex < 0) ? list.Count + startIndex : startIndex;

      // end from the start of the list if end is negitive

      endIndex = (endIndex < 0) ? list.Count + endIndex : endIndex;

      // ensure indexes keep within collection bounds

      startIndex = Math.Max(startIndex, 0);

      endIndex = Math.Min(endIndex, list.Count - 1);

      // loop between start and end indexes, incrementing by the step

      for (int i = startIndex; i < endIndex; i += s)

      {

        slicedList.Add(list[i]);

      }

      return slicedList;

    }

    /// <summary>

    /// Group the collection using a function which returns the key.

    /// <typeparam name="TEnumType">The type of the returned value. Must be assignable from the enum's underlying value type.</typeparam>

    /// <param name="enumType">The enum type to get the maximum value for.</param>

    /// <returns></returns>

    public static TEnumType GetMaximumValue<TEnumType>(Type enumType) where TEnumType : IConvertible, IComparable<TEnumType>

    {

      if (enumType == null)

        throw new ArgumentNullException("enumType");

      Type enumUnderlyingType = Enum.GetUnderlyingType(enumType);

      if (!typeof(TEnumType).IsAssignableFrom(enumUnderlyingType))

        throw new ArgumentException(string.Format(CultureInfo.InvariantCulture, "TEnumType is not assignable from the enum's underlying type of {0}.", enumUnderlyingType.Name));

      ulong maximumValue = 0;

      IList<object> enumValues = GetValues(enumType);

      if (enumType.IsDefined(typeof(FlagsAttribute), false))

      {

        foreach (TEnumType value in enumValues)

        {

          maximumValue = maximumValue | value.ToUInt64(CultureInfo.InvariantCulture);

        }

      }

      else

      {

        foreach (TEnumType value in enumValues)

        {

          ulong tempValue = value.ToUInt64(CultureInfo.InvariantCulture);

          // maximumValue is smaller than the enum value

          if (maximumValue.CompareTo(tempValue) == -1)

            maximumValue = tempValue;

        }

      }

      return (TEnumType)Convert.ChangeType(maximumValue, typeof(TEnumType), CultureInfo.InvariantCulture);

    }

  }

}

    /// </summary>

    /// <param name="list">The list.</param>

    /// <returns>Whether the list's items are their unitialized value</returns>

    public static bool ItemsUnitializedValue<T>(IList<T> list)

    {

      ValidationUtils.ArgumentNotNull(list, "list");

      Type elementType = GetCollectionItemType(list.GetType());

      if (elementType.IsValueType)

      {

        object unitializedValue = CreateUnitializedValue(elementType);

        for (int i = 0; i < list.Count; i++)

        {

          if (!list[i].Equals(unitializedValue))

            return false;

        }

      }

      else if (elementType.IsClass)

      {

        for (int i = 0; i < list.Count; i++)

        {

          object value = list[i];

          if (value != null)

            return false;

        }

      }

      else

      {

        throw new Exception("Type {0} is neither a ValueType or a Class.".FormatWith(CultureInfo.InvariantCulture, elementType));

      }

      return true;

    }

    /// <summary>

    /// Gets the member's underlying type.

    /// </summary>

      }

    }

    public bool Remove(KeyValuePair<TKey, TValue> item)

    {

      if (_genericDictionary != null)

      {

        return _genericDictionary.Remove(item);

      }

      else

      {

        if (_dictionary.Contains(item.Key))

        {

          object value = _dictionary[item.Key];

          if (object.Equals(value, item.Value))

          {

            _dictionary.Remove(item.Key);

            return true;

          }

          else

          {

            return false;

          }

        }

        else

        {

          return true;

        }

      }

    }

    public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()

    {

      if (_genericDictionary != null)

      return Truncate(s, maximumLength, "...");

    }

    public static string Truncate(string s, int maximumLength, string suffix)

    {

      if (suffix == null)

        throw new ArgumentNullException("suffix");

      if (maximumLength <= 0)

        throw new ArgumentException("Maximum length must be greater than zero.", "maximumLength");

      int subStringLength = maximumLength - suffix.Length;

      if (subStringLength <= 0)

        throw new ArgumentException("Length of suffix string is greater or equal to maximumLength");

      if (s != null && s.Length > maximumLength)

      {

        string truncatedString = s.Substring(0, subStringLength);

        // incase the last character is a space

        truncatedString = truncatedString.Trim();

        truncatedString += suffix;

        return truncatedString;

      }

      else

      {

        return s;

      }

    }

    public static StringWriter CreateStringWriter(int capacity)

    {

      StringBuilder sb = new StringBuilder(capacity);

        throw new Exception("Can not create ListWrapper for type {0}.".FormatWith(CultureInfo.InvariantCulture, list.GetType()));

      }

    }

    public static IWrappedList CreateListWrapper(object list)

    {

      ValidationUtils.ArgumentNotNull(list, "list");

      Type listDefinition;

      if (ReflectionUtils.ImplementsGenericDefinition(list.GetType(), typeof(IList<>), out listDefinition))

      {

        Type collectionItemType = ReflectionUtils.GetCollectionItemType(listDefinition);

        // Activator.CreateInstance throws AmbiguousMatchException. Manually invoke constructor

        Func<Type, IList<object>, object> instanceCreator = (t, a) =>

        {

          ConstructorInfo c = t.GetConstructor(new[] {listDefinition});

          return c.Invoke(new[] { list });

        };

        return (IWrappedList)ReflectionUtils.CreateGeneric(typeof(ListWrapper<>), new[] { collectionItemType }, instanceCreator, list);

      }

      else if (list is IList)

      {

        return new ListWrapper<object>((IList)list);

      }

      else

      {

        throw new Exception("Can not create ListWrapper for type {0}.".FormatWith(CultureInfo.InvariantCulture, list.GetType()));

      }

    }

    public static IWrappedDictionary CreateDictionaryWrapper(object dictionary)

    {

      ValidationUtils.ArgumentNotNull(dictionary, "dictionary");

      return test;

    }

    public string SerializeJsonNet(object value)

    {

      Type type = value.GetType();

      Newtonsoft.Json.JsonSerializer json = new Newtonsoft.Json.JsonSerializer();

      json.NullValueHandling = NullValueHandling.Ignore;

      json.ObjectCreationHandling = Newtonsoft.Json.ObjectCreationHandling.Replace;

      json.MissingMemberHandling = Newtonsoft.Json.MissingMemberHandling.Ignore;

      json.ReferenceLoopHandling = ReferenceLoopHandling.Ignore;

      StringWriter sw = new StringWriter();

      Newtonsoft.Json.JsonTextWriter writer = new JsonTextWriter(sw);

      writer.Formatting = Formatting.None;

      writer.QuoteChar = '"';

      json.Serialize(writer, value);

      string output = sw.ToString();

      writer.Close();

      return output;

    }

    public string SerializeWebExtensions(object value)

    {

      JavaScriptSerializer ser = new JavaScriptSerializer();