Code Coverage Statistics for Source File

Newtonsoft.Json.Tests\Converters\StringEnumConverterTests.cs

Symbol Coverage: 100.00% (50 of 50)

Branch Coverage: 100.00% (9 of 9)

Cyclomatic Complexity Avg: 1.00 Max:1

Code Lines: 80

Symbol Coverage Trend

View:


using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Newtonsoft.Json.Converters;
using NUnit.Framework;
using Newtonsoft.Json.Tests.TestObjects;

namespace Newtonsoft.Json.Tests.Converters
{
  public class StringEnumConverterTests : TestFixtureBase
  {
    public class EnumClass
    {
      public StoreColor StoreColor { get; set; }
      public StoreColor? NullableStoreColor1 { get; set; }
      public StoreColor? NullableStoreColor2 { get; set; }
    }

    public enum NegativeEnum
    {
      Negative = -1,
      Zero = 0,
      Positive = 1
    }

    public class NegativeEnumClass
    {
      public NegativeEnum Value1 { get; set; }
      public NegativeEnum Value2 { get; set; }
    }

    [Test]
    public void SerializeEnumClass()
    {
      EnumClass enumClass = new EnumClass();
      enumClass.StoreColor = StoreColor.Red;
      enumClass.NullableStoreColor1 = StoreColor.White;
      enumClass.NullableStoreColor2 = null;

      string json = JsonConvert.SerializeObject(enumClass, Formatting.Indented, new StringEnumConverter());

      Assert.AreEqual(@"{
  ""StoreColor"": ""Red"",
  ""NullableStoreColor1"": ""White"",
  ""NullableStoreColor2"": null
}", json);
    }

    [Test]
    public void SerializeEnumClassUndefined()
    {
      EnumClass enumClass = new EnumClass();
      enumClass.StoreColor = (StoreColor)1000;
      enumClass.NullableStoreColor1 = (StoreColor)1000;
      enumClass.NullableStoreColor2 = null;

      string json = JsonConvert.SerializeObject(enumClass, Formatting.Indented, new StringEnumConverter());

      Assert.AreEqual(@"{
  ""StoreColor"": 1000,
  ""NullableStoreColor1"": 1000,
  ""NullableStoreColor2"": null
}", json);
    }

    [Test]
    public void SerializeFlagEnum()
    {
      EnumClass enumClass = new EnumClass();
      enumClass.StoreColor = StoreColor.Red | StoreColor.White;
      enumClass.NullableStoreColor1 = StoreColor.White & StoreColor.Yellow;
      enumClass.NullableStoreColor2 = StoreColor.Red | StoreColor.White | StoreColor.Black;

      string json = JsonConvert.SerializeObject(enumClass, Formatting.Indented, new StringEnumConverter());

      Assert.AreEqual(@"{
  ""StoreColor"": ""Red, White"",
  ""NullableStoreColor1"": 0,
  ""NullableStoreColor2"": ""Black, Red, White""
}", json);
    }

    [Test]
    public void SerializeNegativeEnum()
    {
      NegativeEnumClass negativeEnumClass = new NegativeEnumClass();
      negativeEnumClass.Value1 = NegativeEnum.Negative;
      negativeEnumClass.Value2 = (NegativeEnum) int.MinValue;

      string json = JsonConvert.SerializeObject(negativeEnumClass, Formatting.Indented, new StringEnumConverter());

      Assert.AreEqual(@"{
  ""Value1"": ""Negative"",
  ""Value2"": -2147483648
}", json);
    }

    [Test]
    public void DeserializeNegativeEnum()
    {
      string json = @"{
  ""Value1"": ""Negative"",
  ""Value2"": -2147483648
}";

      NegativeEnumClass negativeEnumClass = JsonConvert.DeserializeObject<NegativeEnumClass>(json, new StringEnumConverter());

      Assert.AreEqual(NegativeEnum.Negative, negativeEnumClass.Value1);
      Assert.AreEqual((NegativeEnum)int.MinValue, negativeEnumClass.Value2);
    }

    [Test]
    public void DeserializeFlagEnum()
    {
      string json = @"{
  ""StoreColor"": ""Red, White"",
  ""NullableStoreColor1"": 0,
  ""NullableStoreColor2"": ""Black, Red, White""
}";

      EnumClass enumClass = JsonConvert.DeserializeObject<EnumClass>(json, new StringEnumConverter());

      Assert.AreEqual(StoreColor.Red | StoreColor.White, enumClass.StoreColor);
      Assert.AreEqual((StoreColor)0, enumClass.NullableStoreColor1);
      Assert.AreEqual(StoreColor.Red | StoreColor.White | StoreColor.Black, enumClass.NullableStoreColor2);
    }

    [Test]
    public void DeserializeEnumClass()
    {
      string json = @"{
  ""StoreColor"": ""Red"",
  ""NullableStoreColor1"": ""White"",
  ""NullableStoreColor2"": null
}";

      EnumClass enumClass = JsonConvert.DeserializeObject<EnumClass>(json, new StringEnumConverter());

      Assert.AreEqual(StoreColor.Red, enumClass.StoreColor);
      Assert.AreEqual(StoreColor.White, enumClass.NullableStoreColor1);
      Assert.AreEqual(null, enumClass.NullableStoreColor2);
    }

    [Test]
    public void DeserializeEnumClassUndefined()
    {
      string json = @"{
  ""StoreColor"": 1000,
  ""NullableStoreColor1"": 1000,
  ""NullableStoreColor2"": null
}";

      EnumClass enumClass = JsonConvert.DeserializeObject<EnumClass>(json, new StringEnumConverter());

      Assert.AreEqual((StoreColor)1000, enumClass.StoreColor);
      Assert.AreEqual((StoreColor)1000, enumClass.NullableStoreColor1);
      Assert.AreEqual(null, enumClass.NullableStoreColor2);
    }
  }
}

L	V	Source
1		using System;
2		using System.Collections.Generic;
3		using System.Linq;
4		using System.Text;
5		using Newtonsoft.Json.Converters;
6		using NUnit.Framework;
7		using Newtonsoft.Json.Tests.TestObjects;
8
9		namespace Newtonsoft.Json.Tests.Converters
10		{
11		public class StringEnumConverterTests : TestFixtureBase
12		{
13		public class EnumClass
14		{
15		public StoreColor StoreColor { get; set; }
16		public StoreColor? NullableStoreColor1 { get; set; }
17		public StoreColor? NullableStoreColor2 { get; set; }
18		}
19
20		public enum NegativeEnum
21		{
22		Negative = -1,
23		Zero = 0,
24		Positive = 1
25		}
26
27		public class NegativeEnumClass
28		{
29		public NegativeEnum Value1 { get; set; }
30		public NegativeEnum Value2 { get; set; }
31		}
32
33		[Test]
34		public void SerializeEnumClass()
35		{
36	1	EnumClass enumClass = new EnumClass();
37	1	enumClass.StoreColor = StoreColor.Red;
38	1	enumClass.NullableStoreColor1 = StoreColor.White;
39	1	enumClass.NullableStoreColor2 = null;
40
41	1	string json = JsonConvert.SerializeObject(enumClass, Formatting.Indented, new StringEnumConverter());
42
43	1	Assert.AreEqual(@"{
44	1	""StoreColor"": ""Red"",
45	1	""NullableStoreColor1"": ""White"",
46	1	""NullableStoreColor2"": null
47	1	}", json);
48	1	}
49
50		[Test]
51		public void SerializeEnumClassUndefined()
52		{
53	1	EnumClass enumClass = new EnumClass();
54	1	enumClass.StoreColor = (StoreColor)1000;
55	1	enumClass.NullableStoreColor1 = (StoreColor)1000;
56	1	enumClass.NullableStoreColor2 = null;
57
58	1	string json = JsonConvert.SerializeObject(enumClass, Formatting.Indented, new StringEnumConverter());
59
60	1	Assert.AreEqual(@"{
61	1	""StoreColor"": 1000,
62	1	""NullableStoreColor1"": 1000,
63	1	""NullableStoreColor2"": null
64	1	}", json);
65	1	}
66
67		[Test]
68		public void SerializeFlagEnum()
69		{
70	1	EnumClass enumClass = new EnumClass();
71	1	enumClass.StoreColor = StoreColor.Red \| StoreColor.White;
72	1	enumClass.NullableStoreColor1 = StoreColor.White & StoreColor.Yellow;
73	1	enumClass.NullableStoreColor2 = StoreColor.Red \| StoreColor.White \| StoreColor.Black;
74
75	1	string json = JsonConvert.SerializeObject(enumClass, Formatting.Indented, new StringEnumConverter());
76
77	1	Assert.AreEqual(@"{
78	1	""StoreColor"": ""Red, White"",
79	1	""NullableStoreColor1"": 0,
80	1	""NullableStoreColor2"": ""Black, Red, White""
81	1	}", json);
82	1	}
83
84		[Test]
85		public void SerializeNegativeEnum()
86		{
87	1	NegativeEnumClass negativeEnumClass = new NegativeEnumClass();
88	1	negativeEnumClass.Value1 = NegativeEnum.Negative;
89	1	negativeEnumClass.Value2 = (NegativeEnum) int.MinValue;
90
91	1	string json = JsonConvert.SerializeObject(negativeEnumClass, Formatting.Indented, new StringEnumConverter());
92
93	1	Assert.AreEqual(@"{
94	1	""Value1"": ""Negative"",
95	1	""Value2"": -2147483648
96	1	}", json);
97	1	}
98
99		[Test]
100		public void DeserializeNegativeEnum()
101		{
102	1	string json = @"{
103	1	""Value1"": ""Negative"",
104	1	""Value2"": -2147483648
105	1	}";
106
107	1	NegativeEnumClass negativeEnumClass = JsonConvert.DeserializeObject<NegativeEnumClass>(json, new StringEnumConverter());
108
109	1	Assert.AreEqual(NegativeEnum.Negative, negativeEnumClass.Value1);
110	1	Assert.AreEqual((NegativeEnum)int.MinValue, negativeEnumClass.Value2);
111	1	}
112
113		[Test]
114		public void DeserializeFlagEnum()
115		{
116	1	string json = @"{
117	1	""StoreColor"": ""Red, White"",
118	1	""NullableStoreColor1"": 0,
119	1	""NullableStoreColor2"": ""Black, Red, White""
120	1	}";
121
122	1	EnumClass enumClass = JsonConvert.DeserializeObject<EnumClass>(json, new StringEnumConverter());
123
124	1	Assert.AreEqual(StoreColor.Red \| StoreColor.White, enumClass.StoreColor);
125	1	Assert.AreEqual((StoreColor)0, enumClass.NullableStoreColor1);
126	1	Assert.AreEqual(StoreColor.Red \| StoreColor.White \| StoreColor.Black, enumClass.NullableStoreColor2);
127	1	}
128
129		[Test]
130		public void DeserializeEnumClass()
131		{
132	1	string json = @"{
133	1	""StoreColor"": ""Red"",
134	1	""NullableStoreColor1"": ""White"",
135	1	""NullableStoreColor2"": null
136	1	}";
137
138	1	EnumClass enumClass = JsonConvert.DeserializeObject<EnumClass>(json, new StringEnumConverter());
139
140	1	Assert.AreEqual(StoreColor.Red, enumClass.StoreColor);
141	1	Assert.AreEqual(StoreColor.White, enumClass.NullableStoreColor1);
142	1	Assert.AreEqual(null, enumClass.NullableStoreColor2);
143	1	}
144
145		[Test]
146		public void DeserializeEnumClassUndefined()
147		{
148	1	string json = @"{
149	1	""StoreColor"": 1000,
150	1	""NullableStoreColor1"": 1000,
151	1	""NullableStoreColor2"": null
152	1	}";
153
154	1	EnumClass enumClass = JsonConvert.DeserializeObject<EnumClass>(json, new StringEnumConverter());
155
156	1	Assert.AreEqual((StoreColor)1000, enumClass.StoreColor);
157	1	Assert.AreEqual((StoreColor)1000, enumClass.NullableStoreColor1);
158	1	Assert.AreEqual(null, enumClass.NullableStoreColor2);
159	1	}
160		}
161		}