PageRenderTime 27ms CodeModel.GetById 0ms RepoModel.GetById 0ms app.codeStats 0ms

/test/System.Net.Http.Formatting.Test.Integration/FormUrlEncodedFromContentTests.cs

https://bitbucket.org/mdavid/aspnetwebstack
C# | 527 lines | 478 code | 24 blank | 25 comment | 1 complexity | 2e351870eea1a50ebd4445d815f86581 MD5 | raw file
    

  1. using System.Collections.Generic;
    2. 

  2. using System.Json;
    3. 

  3. using System.Net.Http.Formatting.Parsers;
    4. 

  4. using System.Net.Http.Internal;
    5. 

  5. using System.Text;
    6. 

  6. using Newtonsoft.Json.Linq;
    7. 

  7. using Xunit;
    8. 

  8. using Xunit.Extensions;
    9. 

  9. using Assert = Microsoft.TestCommon.AssertEx;
    10. 

  10. 

  11. namespace System.Net.Http.Formatting
    12. 

  12. {
    13. 

  13.     public class FormUrlEncodedJsonFromContentTests
    14. 

  14.     {
    15. 

  15.         #region Tests
    16. 

  16. 

  17.         [Theory,
    18. 

  18.             InlineData("abc", "{\"abc\":\"\"}"),
    19. 

  19.             InlineData("%2eabc%2e", "{\".abc.\":\"\"}"),
    20. 

  20.             InlineData("", "{}"),
    21. 

  21.             InlineData("a=1", "{\"a\":\"1\"}")]
    22. 

  22.         public void SimpleStringsTest(string encoded, string expectedResult)
    23. 

  23.         {
    24. 

  24.             ValidateFormUrlEncoded(encoded, expectedResult);
    25. 

  25. 

  26.         }
    27. 

  27. 

  28.         [Theory,
    29. 

  29.             InlineData("a=2", "{\"a\":\"2\"}"),
    30. 

  30.             InlineData("b=true", "{\"b\":\"true\"}"),
    31. 

  31.             InlineData("c=hello", "{\"c\":\"hello\"}"),
    32. 

  32.             InlineData("d=", "{\"d\":\"\"}"),
    33. 

  33.             InlineData("e=null", "{\"e\":\"null\"}")]
    34. 

  34.         public void SimpleObjectsTest(string encoded, string expectedResult)
    35. 

  35.         {
    36. 

  36.             ValidateFormUrlEncoded(encoded, expectedResult);
    37. 

  37. 

  38.         }
    39. 

  39. 

  40.         [Fact]
    41. 

  41.         public void LegacyArraysTest()
    42. 

  42.         {
    43. 

  43.             ValidateFormUrlEncoded("a=1&a=hello&a=333", "{\"a\":[\"1\",\"hello\",\"333\"]}");
    44. 

  44. 

  45.             // Only valid in shallow serialization
    46. 

  46.             ParseInvalidFormUrlEncoded("a[z]=2&a[z]=3");
    47. 

  47.         }
    48. 

  48. 

  49.         [Theory,
    50. 

  50.             InlineData("a[]=1&a[]=hello&a[]=333", "{\"a\":[\"1\",\"hello\",\"333\"]}"),
    51. 

  51.             InlineData("a[b][]=1&a[b][]=hello&a[b][]=333", "{\"a\":{\"b\":[\"1\",\"hello\",\"333\"]}}"),
    52. 

  52.             InlineData("a[]=", "{\"a\":[\"\"]}"),
    53. 

  53.             InlineData("a%5B%5D=2", @"{""a"":[""2""]}"),
    54. 

  54.             InlineData("a[x][0]=1&a[x][]=2", @"{""a"":{""x"":[""1"",""2""]}}")]
    55. 

  55.         public void ArraysTest(string encoded, string expectedResult)
    56. 

  56.         {
    57. 

  57.             ValidateFormUrlEncoded(encoded, expectedResult);
    58. 

  58.         }
    59. 

  59. 

  60.         [Theory,
    61. 

  61.             InlineData("a[0][]=1&a[0][]=hello&a[1][]=333", "{\"a\":[[\"1\",\"hello\"],[\"333\"]]}"),
    62. 

  62.             InlineData("a[b][0][]=1&a[b][1][]=hello&a[b][1][]=333", "{\"a\":{\"b\":[[\"1\"],[\"hello\",\"333\"]]}}"),
    63. 

  63.             InlineData("a[0][0][0][]=1", "{\"a\":[[[[\"1\"]]]]}")]
    64. 

  64.         public void MultidimensionalArraysTest(string encoded, string expectedResult)
    65. 

  65.         {
    66. 

  66.             ValidateFormUrlEncoded(encoded, expectedResult);
    67. 

  67.         }
    68. 

  68. 

  69.         [Theory,
    70. 

  70.             InlineData("a[0][]=hello&a[2][]=333", "{\"a\":{\"0\":[\"hello\"],\"2\":[\"333\"]}}"),
    71. 

  71.             InlineData("a[0]=hello", "{\"a\":[\"hello\"]}"),
    72. 

  72.             InlineData("a[1][]=hello", "{\"a\":{\"1\":[\"hello\"]}}"),
    73. 

  73.             InlineData("a[1][0]=hello", "{\"a\":{\"1\":[\"hello\"]}}")]
    74. 

  74.         public void SparseArraysTest(string encoded, string expectedResult)
    75. 

  75.         {
    76. 

  76.             ValidateFormUrlEncoded(encoded, expectedResult);
    77. 

  77.         }
    78. 

  78. 

  79.         [Theory,
    80. 

  80.             InlineData("b[]=2&b[1][c]=d", "{\"b\":[\"2\",{\"c\":\"d\"}]}")]
    81. 

  81.         public void ArraysWithMixedMembers(string encoded, string expectedResult)
    82. 

  82.         {
    83. 

  83.             ValidateFormUrlEncoded(encoded, expectedResult);
    84. 

  84.         }
    85. 

  85. 

  86.         [Theory,
    87. 

  87.             InlineData("=3", "{\"\":\"3\"}"),
    88. 

  88.             InlineData("a=1&=3", "{\"a\":\"1\",\"\":\"3\"}"),
    89. 

  89.             InlineData("=3&b=2", "{\"\":\"3\",\"b\":\"2\"}")]
    90. 

  90.         public void EmptyKeyTest(string encoded, string expectedResult)
    91. 

  91.         {
    92. 

  92.             ValidateFormUrlEncoded(encoded, expectedResult);
    93. 

  93.         }
    94. 

  94. 

  95.         [Theory,
    96. 

  96.             InlineData("a[b]=1&a=2"),
    97. 

  97.             InlineData("a[b]=1&a[b][]=2"),
    98. 

  98.             InlineData("a[x][]=1&a[x][0]=2"),
    99. 

  99.             InlineData("a=2&a[b]=1"),
    100. 

  100.             InlineData("[]=1"),
    101. 

  101.             InlineData("a[][]=0"),
    102. 

  102.             InlineData("a[][x]=0"),
    103. 

  103.             InlineData("a&a[b]=1")]
    104. 

  104.         public void InvalidObjectGraphsTest(string encoded)
    105. 

  105.         {
    106. 

  106.             ParseInvalidFormUrlEncoded(encoded);
    107. 

  107.         }
    108. 

  108. 

  109.         [Theory,
    110. 

  110.             InlineData("a[b=2"),
    111. 

  111.             InlineData("a[[b]=2"),
    112. 

  112.             InlineData("a[b]]=2")]
    113. 

  113.         public void InvalidFormUrlEncodingTest(string encoded)
    114. 

  114.         {
    115. 

  115.             ParseInvalidFormUrlEncoded(encoded);
    116. 

  116.         }
    117. 

  117. 

  118.         /// <summary>
    119. 

  119.         /// Tests for parsing form-urlencoded data originated from JS primitives.
    120. 

  120.         /// </summary>
    121. 

  121.         [Theory,
    122. 

  122.             InlineData("abc", @"{""abc"":""""}"),
    123. 

  123.             InlineData("123", @"{""123"":""""}"),
    124. 

  124.             InlineData("true", @"{""true"":""""}"),
    125. 

  125.             InlineData("", "{}"),
    126. 

  126.             InlineData("%2fabc%2f", @"{""/abc/"":""""}")]
    127. 

  127.         public void TestJValue(string encoded, string expectedResult)
    128. 

  128.         {
    129. 

  129.             ValidateFormUrlEncoded(encoded, expectedResult);
    130. 

  130.         }
    131. 

  131. 

  132.         /// <summary>
    133. 

  133.         /// Negative tests for parsing form-urlencoded data originated from JS primitives.
    134. 

  134.         /// </summary>
    135. 

  135.         [Theory,
    136. 

  136.             InlineData("a[b]=1&a=2"),
    137. 

  137.             InlineData("a=2&a[b]=1"),
    138. 

  138.             InlineData("[]=1")]
    139. 

  139.         public void TestJValueNegative(string encoded)
    140. 

  140.         {
    141. 

  141.             ParseInvalidFormUrlEncoded(encoded);
    142. 

  142.         }
    143. 

  143. 

  144.         /// <summary>
    145. 

  145.         /// Tests for parsing form-urlencoded data originated from JS objects.
    146. 

  146.         /// </summary>
    147. 

  147.         [Theory,
    148. 

  148.             InlineData("a=NaN", @"{""a"":""NaN""}"),
    149. 

  149.             InlineData("a=false", @"{""a"":""false""}"),
    150. 

  150.             InlineData("a=foo", @"{""a"":""foo""}"),
    151. 

  151.             InlineData("1=1", "{\"1\":\"1\"}")]
    152. 

  152.         public void TestObjects(string encoded, string expectedResult)
    153. 

  153.         {
    154. 

  154.             ValidateFormUrlEncoded(encoded, expectedResult);
    155. 

  155.         }
    156. 

  156. 

  157.         /// <summary>
    158. 

  158.         /// Tests for parsing form-urlencoded data originated from JS arrays.
    159. 

  159.         /// </summary>
    160. 

  160.         [Theory,
    161. 

  161.             InlineData("a[]=2", @"{""a"":[""2""]}"),
    162. 

  162.             InlineData("a[]=", @"{""a"":[""""]}"),
    163. 

  163.             InlineData("a[0][0][]=1", @"{""a"":[[[""1""]]]}"),
    164. 

  164.             InlineData("z[]=9&z[]=true&z[]=undefined&z[]=", @"{""z"":[""9"",""true"",""undefined"",""""]}"),
    165. 

  165.             InlineData("z[]=9&z[]=true&z[]=undefined&z[]=null", @"{""z"":[""9"",""true"",""undefined"",""null""]}"),
    166. 

  166.             InlineData("z[0][]=9&z[0][]=true&z[1][]=undefined&z[1][]=null", @"{""z"":[[""9"",""true""],[""undefined"",""null""]]}"),
    167. 

  167.             InlineData("a[0][x]=2", @"{""a"":[{""x"":""2""}]}"),
    168. 

  168.             InlineData("a%5B%5D=2", @"{""a"":[""2""]}"),
    169. 

  169.             InlineData("a%5B%5D=", @"{""a"":[""""]}"),
    170. 

  170.             InlineData("z%5B%5D=9&z%5B%5D=true&z%5B%5D=undefined&z%5B%5D=", @"{""z"":[""9"",""true"",""undefined"",""""]}"),
    171. 

  171.             InlineData("z%5B%5D=9&z%5B%5D=true&z%5B%5D=undefined&z%5B%5D=null", @"{""z"":[""9"",""true"",""undefined"",""null""]}"),
    172. 

  172.             InlineData("z%5B0%5D%5B%5D=9&z%5B0%5D%5B%5D=true&z%5B1%5D%5B%5D=undefined&z%5B1%5D%5B%5D=null", @"{""z"":[[""9"",""true""],[""undefined"",""null""]]}")]
    173. 

  173.         public void TestArray(string encoded, string expectedResult)
    174. 

  174.         {
    175. 

  175.             ValidateFormUrlEncoded(encoded, expectedResult);
    176. 

  176.         }
    177. 

  177. 

  178.         /// <summary>
    179. 

  179.         /// Tests for parsing form-urlencoded data originated from JS arrays, using the jQuery 1.3 format (no []'s).
    180. 

  180.         /// </summary>
    181. 

  181.         [Theory,
    182. 

  182.             InlineData("z=9&z=true&z=undefined&z=", @"{""z"":[""9"",""true"",""undefined"",""""]}"),
    183. 

  183.             InlineData("z=9&z=true&z=undefined&z=null", @"{""z"":[""9"",""true"",""undefined"",""null""]}"),
    184. 

  184.             InlineData("z=9&z=true&z=undefined&z=null&a=hello", @"{""z"":[""9"",""true"",""undefined"",""null""],""a"":""hello""}")]
    185. 

  185.         public void TestArrayCompat(string encoded, string expectedResult)
    186. 

  186.         {
    187. 

  187.             ValidateFormUrlEncoded(encoded, expectedResult);
    188. 

  188.         }
    189. 

  189. 

  190.         /// <summary>
    191. 

  191.         /// Negative tests for parsing form-urlencoded data originated from JS arrays.
    192. 

  192.         /// </summary>
    193. 

  193.         [Theory,
    194. 

  194.             InlineData("a[z]=2&a[z]=3")]
    195. 

  195.         public void TestArrayCompatNegative(string encoded)
    196. 

  196.         {
    197. 

  197.             ParseInvalidFormUrlEncoded(encoded);
    198. 

  198.         }
    199. 

  199. 

  200.         /// <summary>
    201. 

  201.         /// Tests for form-urlencoded data originated from sparse JS arrays.
    202. 

  202.         /// </summary>
    203. 

  203.         [Theory,
    204. 

  204.             InlineData("a[2]=hello", @"{""a"":{""2"":""hello""}}"),
    205. 

  205.             InlineData("a[x][0]=2", @"{""a"":{""x"":[""2""]}}"),
    206. 

  206.             InlineData("a[x][1]=2", @"{""a"":{""x"":{""1"":""2""}}}"),
    207. 

  207.             InlineData("a[x][0]=0&a[x][1]=1", @"{""a"":{""x"":[""0"",""1""]}}"),
    208. 

  208.             InlineData("a[0][0][0]=hello&a[1][0][0][0][]=hello", @"{""a"":[[[""hello""]],[[[[""hello""]]]]]}"),
    209. 

  209.             InlineData("a[0][0][0]=hello&a[1][0][0][0]=hello", @"{""a"":[[[""hello""]],[[[""hello""]]]]}"),
    210. 

  210.             InlineData("a[1][0][]=1", @"{""a"":{""1"":[[""1""]]}}"),
    211. 

  211.             InlineData("a[1][1][]=1", @"{""a"":{""1"":{""1"":[""1""]}}}"),
    212. 

  212.             InlineData("a[1][1][0]=1", @"{""a"":{""1"":{""1"":[""1""]}}}"),
    213. 

  213.             InlineData("a[0][]=2&a[0][]=3&a[2][]=1", "{\"a\":{\"0\":[\"2\",\"3\"],\"2\":[\"1\"]}}"),
    214. 

  214.             InlineData("a[x][]=1&a[x][1]=2", @"{""a"":{""x"":[""1"",""2""]}}"),
    215. 

  215.             InlineData("a[x][0]=1&a[x][]=2", @"{""a"":{""x"":[""1"",""2""]}}")]
    216. 

  216.         public void TestArraySparse(string encoded, string expectedResult)
    217. 

  217.         {
    218. 

  218.             ValidateFormUrlEncoded(encoded, expectedResult);
    219. 

  219.         }
    220. 

  220. 

  221.         /// <summary>
    222. 

  222.         /// Negative tests for parsing form-urlencoded arrays.
    223. 

  223.         /// </summary>
    224. 

  224.         [Theory,
    225. 

  225.             InlineData("a[x]=2&a[x][]=3"),
    226. 

  226.             InlineData("a[]=1&a[0][]=2"),
    227. 

  227.             InlineData("a[]=1&a[0][0][]=2"),
    228. 

  228.             InlineData("a[x][]=1&a[x][0]=2"),
    229. 

  229.             InlineData("a[][]=0"),
    230. 

  230.             InlineData("a[][x]=0")]
    231. 

  231.         public void TestArrayIndexNegative(string encoded)
    232. 

  232.         {
    233. 

  233.             ParseInvalidFormUrlEncoded(encoded);
    234. 

  234.         }
    235. 

  235. 

  236.         public static IEnumerable<object[]> TestObjectTestData
    237. 

  237.         {
    238. 

  238.             get
    239. 

  239.             {
    240. 

  240.                 string encoded = "a[]=4&a[]=5&b[x][]=7&b[y]=8&b[z][]=9&b[z][]=true&b[z][]=undefined&b[z][]=&c=1&f=";
    241. 

  241.                 string resultStr = @"{""a"":[""4"",""5""],""b"":{""x"":[""7""],""y"":""8"",""z"":[""9"",""true"",""undefined"",""""]},""c"":""1"",""f"":""""}";
    242. 

  242.                 yield return new[] { encoded, resultStr };
    243. 

  243. 

  244.                 encoded = "customer[Name]=Pete&customer[Address]=Redmond&customer[Age][0][]=23&customer[Age][0][]=24&customer[Age][1][]=25&" +
    245. 

  245.                     "customer[Age][1][]=26&customer[Phones][]=425+888+1111&customer[Phones][]=425+345+7777&customer[Phones][]=425+888+4564&" +
    246. 

  246.                     "customer[EnrolmentDate]=%22%5C%2FDate(1276562539537)%5C%2F%22&role=NewRole&changeDate=3&count=15";
    247. 

  247.                 resultStr = @"{""customer"":{""Name"":""Pete"",""Address"":""Redmond"",""Age"":[[""23"",""24""],[""25"",""26""]]," +
    248. 

  248.                     @"""Phones"":[""425 888 1111"",""425 345 7777"",""425 888 4564""],""EnrolmentDate"":""\""\\/Date(1276562539537)\\/\""""},""role"":""NewRole"",""changeDate"":""3"",""count"":""15""}";
    249. 

  249.                 yield return new[] { encoded, resultStr };
    250. 

  250. 

  251.                 encoded = "customers[0][Name]=Pete2&customers[0][Address]=Redmond2&customers[0][Age][0][]=23&customers[0][Age][0][]=24&" +
    252. 

  252.                     "customers[0][Age][1][]=25&customers[0][Age][1][]=26&customers[0][Phones][]=425+888+1111&customers[0][Phones][]=425+345+7777&" +
    253. 

  253.                     "customers[0][Phones][]=425+888+4564&customers[0][EnrolmentDate]=%22%5C%2FDate(1276634840700)%5C%2F%22&customers[1][Name]=Pete3&" +
    254. 

  254.                     "customers[1][Address]=Redmond3&customers[1][Age][0][]=23&customers[1][Age][0][]=24&customers[1][Age][1][]=25&customers[1][Age][1][]=26&" +
    255. 

  255.                     "customers[1][Phones][]=425+888+1111&customers[1][Phones][]=425+345+7777&customers[1][Phones][]=425+888+4564&customers[1][EnrolmentDate]=%22%5C%2FDate(1276634840700)%5C%2F%22";
    256. 

  256.                 resultStr = @"{""customers"":[{""Name"":""Pete2"",""Address"":""Redmond2"",""Age"":[[""23"",""24""],[""25"",""26""]]," +
    257. 

  257.                     @"""Phones"":[""425 888 1111"",""425 345 7777"",""425 888 4564""],""EnrolmentDate"":""\""\\/Date(1276634840700)\\/\""""}," +
    258. 

  258.                     @"{""Name"":""Pete3"",""Address"":""Redmond3"",""Age"":[[""23"",""24""],[""25"",""26""]],""Phones"":[""425 888 1111"",""425 345 7777"",""425 888 4564""],""EnrolmentDate"":""\""\\/Date(1276634840700)\\/\""""}]}";
    259. 

  259.                 yield return new[] { encoded, resultStr };
    260. 

  260. 

  261.                 encoded = "ab%5B%5D=hello";
    262. 

  262.                 resultStr = @"{""ab"":[""hello""]}";
    263. 

  263.                 yield return new[] { encoded, resultStr };
    264. 

  264. 

  265.                 encoded = "123=hello";
    266. 

  266.                 resultStr = @"{""123"":""hello""}";
    267. 

  267.                 yield return new[] { encoded, resultStr };
    268. 

  268. 

  269.                 encoded = "a%5B%5D=1&a";
    270. 

  270.                 resultStr = @"{""a"":[""1"",""""]}";
    271. 

  271.                 yield return new[] { encoded, resultStr };
    272. 

  272. 

  273.                 encoded = "a=1&a";
    274. 

  274.                 resultStr = @"{""a"":[""1"",""""]}";
    275. 

  275.                 yield return new[] { encoded, resultStr };
    276. 

  276.             }
    277. 

  277.         }
    278. 

  278. 

  279.         /// <summary>
    280. 

  280.         /// Tests for parsing complex object graphs form-urlencoded.
    281. 

  281.         /// </summary>
    282. 

  282.         [Theory]
    283. 

  283.         [PropertyData("TestObjectTestData")]
    284. 

  284.         public void TestObject(string encoded, string expectedResult)
    285. 

  285.         {
    286. 

  286.             ValidateFormUrlEncoded(encoded, expectedResult);
    287. 

  287.         }
    288. 

  288. 

  289. 

  290.         public static IEnumerable<object[]> TestEncodedNameTestData
    291. 

  291.         {
    292. 

  292.             get
    293. 

  293.             {
    294. 

  294.                 string encoded = "some+thing=10";
    295. 

  295.                 string resultStr = @"{""some thing"":""10""}";
    296. 

  296.                 yield return new[] { encoded, resultStr };
    297. 

  297. 

  298.                 encoded = "%E5%B8%A6%E4%B8%89%E4%B8%AA%E8%A1%A8=bar";
    299. 

  299.                 resultStr = @"{""带三个表"":""bar""}";
    300. 

  300.                 yield return new[] { encoded, resultStr };
    301. 

  301. 

  302.                 encoded = "some+thing=10&%E5%B8%A6%E4%B8%89%E4%B8%AA%E8%A1%A8=bar";
    303. 

  303.                 resultStr = @"{""some thing"":""10"",""带三个表"":""bar""}";
    304. 

  304.                 yield return new[] { encoded, resultStr };
    305. 

  305. 

  306.                 encoded = "a[0\r\n][b]=1";
    307. 

  307.                 resultStr = "{\"a\":{\"0\\r\\n\":{\"b\":\"1\"}}}";
    308. 

  308.                 yield return new[] { encoded, resultStr };
    309. 

  309.                 yield return new[] { encoded.Replace("\r", "%0D").Replace("\n", "%0A"), resultStr };
    310. 

  310. 

  311.                 yield return new[] { "a[0\0]=1", "{\"a\":{\"0\\u0000\":\"1\"}}" };
    312. 

  312.                 yield return new[] { "a[0%00]=1", "{\"a\":{\"0\\u0000\":\"1\"}}" };
    313. 

  313.                 yield return new[] { "a[\00]=1", "{\"a\":{\"\\u00000\":\"1\"}}" };
    314. 

  314.                 yield return new[] { "a[%000]=1", "{\"a\":{\"\\u00000\":\"1\"}}" };
    315. 

  315.             }
    316. 

  316.         }
    317. 

  317.         /// <summary>
    318. 

  318.         /// Tests for parsing form-urlencoded data with encoded names.
    319. 

  319.         /// </summary>
    320. 

  320.         [Theory]
    321. 

  321.         [PropertyData("TestEncodedNameTestData")]
    322. 

  322.         public void TestEncodedName(string encoded, string expectedResult)
    323. 

  323.         {
    324. 

  324.             ValidateFormUrlEncoded(encoded, expectedResult);
    325. 

  325.         }
    326. 

  326. 

  327.         /// <summary>
    328. 

  328.         /// Tests for malformed form-urlencoded data.
    329. 

  329.         /// </summary>
    330. 

  330.         [Theory,
    331. 

  331.             InlineData("a[b=2"),
    332. 

  332.             InlineData("a[[b]=2"),
    333. 

  333.             InlineData("a[b]]=2")]
    334. 

  334.         public void TestNegative(string encoded)
    335. 

  335.         {
    336. 

  336.             ParseInvalidFormUrlEncoded(encoded);
    337. 

  337.         }
    338. 

  338. 

  339.         /// <summary>
    340. 

  340.         /// Tests for parsing generated form-urlencoded data.
    341. 

  341.         /// </summary>
    342. 

  342.         [Fact]
    343. 

  343.         public void GeneratedJTokenTest()
    344. 

  344.         {
    345. 

  345.             Random rndGen = new Random(1);
    346. 

  346.             int oldMaxArray = CreatorSettings.MaxArrayLength;
    347. 

  347.             int oldMaxList = CreatorSettings.MaxListLength;
    348. 

  348.             int oldMaxStr = CreatorSettings.MaxStringLength;
    349. 

  349.             double oldNullProbability = CreatorSettings.NullValueProbability;
    350. 

  350.             bool oldCreateAscii = CreatorSettings.CreateOnlyAsciiChars;
    351. 

  351.             CreatorSettings.MaxArrayLength = 5;
    352. 

  352.             CreatorSettings.MaxListLength = 3;
    353. 

  353.             CreatorSettings.MaxStringLength = 3;
    354. 

  354.             CreatorSettings.NullValueProbability = 0;
    355. 

  355.             CreatorSettings.CreateOnlyAsciiChars = true;
    356. 

  356.             JTokenCreatorSurrogate jsonValueCreator = new JTokenCreatorSurrogate();
    357. 

  357.             try
    358. 

  358.             {
    359. 

  359.                 for (int i = 0; i < 1000; i++)
    360. 

  360.                 {
    361. 

  361.                     JToken jv = (JToken)jsonValueCreator.CreateInstanceOf(typeof(JToken), rndGen);
    362. 

  362.                     if (jv.Type == JTokenType.Array || jv.Type == JTokenType.Object)
    363. 

  363.                     {
    364. 

  364.                         string jaStr = FormUrlEncoding(jv);
    365. 

  365.                         byte[] data = Encoding.UTF8.GetBytes(jaStr);
    366. 

  366.                         for (var cnt = 1; cnt <= data.Length; cnt += 4)
    367. 

  367.                         {
    368. 

  368.                             ICollection<KeyValuePair<string, string>> collection;
    369. 

  369.                             FormUrlEncodedParser parser = FormUrlEncodedParserTests.CreateParser(data.Length + 1, out collection);
    370. 

  370.                             Assert.NotNull(parser);
    371. 

  371. 

  372.                             int totalBytesConsumed;
    373. 

  373.                             ParserState state = FormUrlEncodedParserTests.ParseBufferInSteps(parser, data, cnt, out totalBytesConsumed);
    374. 

  374.                             Assert.Equal(ParserState.Done, state);
    375. 

  375.                             Assert.Equal(data.Length, totalBytesConsumed);
    376. 

  376. 

  377.                             JObject deserJo = FormUrlEncodedJson.Parse(collection);
    378. 

  378.                             Assert.NotNull(deserJo);
    379. 

  379.                             bool compare = true;
    380. 

  380.                             if (((IDictionary<string, JToken>)deserJo).ContainsKey("JV"))
    381. 

  381.                             {
    382. 

  382.                                 compare = JTokenRoundTripComparer.Compare(jv, deserJo["JV"]);
    383. 

  383.                             }
    384. 

  384.                             else
    385. 

  385.                             {
    386. 

  386.                                 compare = JTokenRoundTripComparer.Compare(jv, deserJo);
    387. 

  387.                             }
    388. 

  388. 

  389.                             Assert.True(compare, "Comparison failed for test instance " + i);
    390. 

  390.                         }
    391. 

  391.                     }
    392. 

  392.                 }
    393. 

  393.             }
    394. 

  394.             finally
    395. 

  395.             {
    396. 

  396.                 CreatorSettings.MaxArrayLength = oldMaxArray;
    397. 

  397.                 CreatorSettings.MaxListLength = oldMaxList;
    398. 

  398.                 CreatorSettings.MaxStringLength = oldMaxStr;
    399. 

  399.                 CreatorSettings.NullValueProbability = oldNullProbability;
    400. 

  400.                 CreatorSettings.CreateOnlyAsciiChars = oldCreateAscii;
    401. 

  401.             }
    402. 

  402.         }
    403. 

  403. 

  404.         #endregion
    405. 

  405. 

  406.         #region Helpers
    407. 

  407. 

  408.         private static string FormUrlEncoding(JToken jsonValue)
    409. 

  409.         {
    410. 

  410.             List<string> results = new List<string>();
    411. 

  411.             if (jsonValue is JValue)
    412. 

  412.             {
    413. 

  413.                 return UriQueryUtility.UrlEncode(((JValue)jsonValue).Value.ToString());
    414. 

  414.             }
    415. 

  415. 

  416.             BuildParams("JV", jsonValue, results);
    417. 

  417.             StringBuilder strResult = new StringBuilder();
    418. 

  418.             foreach (var result in results)
    419. 

  419.             {
    420. 

  420.                 strResult.Append("&" + result);
    421. 

  421.             }
    422. 

  422. 

  423.             if (strResult.Length > 0)
    424. 

  424.             {
    425. 

  425.                 return strResult.Remove(0, 1).ToString();
    426. 

  426.             }
    427. 

  427. 

  428.             return strResult.ToString();
    429. 

  429.         }
    430. 

  430. 

  431.         private static void BuildParams(string prefix, JToken jsonValue, List<string> results)
    432. 

  432.         {
    433. 

  433.             if (jsonValue is JValue)
    434. 

  434.             {
    435. 

  435.                 JValue jsonPrimitive = jsonValue as JValue;
    436. 

  436.                 if (jsonPrimitive != null)
    437. 

  437.                 {
    438. 

  438.                     if (jsonPrimitive.Type == JTokenType.String && String.IsNullOrEmpty(jsonPrimitive.Value.ToString()))
    439. 

  439.                     {
    440. 

  440.                         results.Add(prefix + "=" + String.Empty);
    441. 

  441.                     }
    442. 

  442.                     else
    443. 

  443.                     {
    444. 

  444.                         if (jsonPrimitive.Value is DateTime || jsonPrimitive.Value is DateTimeOffset)
    445. 

  445.                         {
    446. 

  446.                             string dateStr = jsonPrimitive.ToString();
    447. 

  447.                             if (!String.IsNullOrEmpty(dateStr) && dateStr.StartsWith("\""))
    448. 

  448.                             {
    449. 

  449.                                 dateStr = dateStr.Substring(1, dateStr.Length - 2);
    450. 

  450.                             }
    451. 

  451.                             results.Add(prefix + "=" + UriQueryUtility.UrlEncode(dateStr));
    452. 

  452.                         }
    453. 

  453.                         else
    454. 

  454.                         {
    455. 

  455.                             results.Add(prefix + "=" + UriQueryUtility.UrlEncode(jsonPrimitive.Value.ToString()));
    456. 

  456.                         }
    457. 

  457.                     }
    458. 

  458.                 }
    459. 

  459.                 else
    460. 

  460.                 {
    461. 

  461.                     results.Add(prefix + "=" + String.Empty);
    462. 

  462.                 }
    463. 

  463.             }
    464. 

  464.             else if (jsonValue is JArray)
    465. 

  465.             {
    466. 

  466.                 for (int i = 0; i < ((JArray)jsonValue).Count; i++)
    467. 

  467.                 {
    468. 

  468.                     if (jsonValue[i] is JArray || jsonValue[i] is JObject)
    469. 

  469.                     {
    470. 

  470.                         BuildParams(prefix + "[" + i + "]", jsonValue[i], results);
    471. 

  471.                     }
    472. 

  472.                     else
    473. 

  473.                     {
    474. 

  474.                         BuildParams(prefix + "[]", jsonValue[i], results);
    475. 

  475.                     }
    476. 

  476.                 }
    477. 

  477.             }
    478. 

  478.             else //jsonValue is JObject
    479. 

  479.             {
    480. 

  480.                 foreach (KeyValuePair<string, JToken> item in (JObject)jsonValue)
    481. 

  481.                 {
    482. 

  482.                     BuildParams(prefix + "[" + item.Key + "]", item.Value, results);
    483. 

  483.                 }
    484. 

  484.             }
    485. 

  485.         }
    486. 

  486. 

  487.         private static void ParseInvalidFormUrlEncoded(string encoded)
    488. 

  488.         {
    489. 

  489.             byte[] data = Encoding.UTF8.GetBytes(encoded);
    490. 

  490.             for (var cnt = 1; cnt <= data.Length; cnt++)
    491. 

  491.             {
    492. 

  492.                 ICollection<KeyValuePair<string, string>> collection;
    493. 

  493.                 FormUrlEncodedParser parser = FormUrlEncodedParserTests.CreateParser(data.Length + 1, out collection);
    494. 

  494.                 Assert.NotNull(parser);
    495. 

  495. 

  496.                 int totalBytesConsumed;
    497. 

  497.                 ParserState state = FormUrlEncodedParserTests.ParseBufferInSteps(parser, data, cnt, out totalBytesConsumed);
    498. 

  498.                 Assert.Equal(ParserState.Done, state);
    499. 

  499.                 Assert.Equal(data.Length, totalBytesConsumed);
    500. 

  500. 

  501.                 Assert.ThrowsArgument(() => { FormUrlEncodedJson.Parse(collection); }, null);
    502. 

  502.             }
    503. 

  503.         }
    504. 

  504. 

  505.         private static void ValidateFormUrlEncoded(string encoded, string expectedResult)
    506. 

  506.         {
    507. 

  507.             byte[] data = Encoding.UTF8.GetBytes(encoded);
    508. 

  508.             for (var cnt = 1; cnt <= data.Length; cnt++)
    509. 

  509.             {
    510. 

  510.                 ICollection<KeyValuePair<string, string>> collection;
    511. 

  511.                 FormUrlEncodedParser parser = FormUrlEncodedParserTests.CreateParser(data.Length + 1, out collection);
    512. 

  512.                 Assert.NotNull(parser);
    513. 

  513. 

  514.                 int totalBytesConsumed;
    515. 

  515.                 ParserState state = FormUrlEncodedParserTests.ParseBufferInSteps(parser, data, cnt, out totalBytesConsumed);
    516. 

  516.                 Assert.Equal(ParserState.Done, state);
    517. 

  517.                 Assert.Equal(data.Length, totalBytesConsumed);
    518. 

  518. 

  519.                 JObject result = FormUrlEncodedJson.Parse(collection);
    520. 

  520.                 Assert.NotNull(result);
    521. 

  521.                 Assert.Equal(expectedResult, result.ToString(Newtonsoft.Json.Formatting.None));
    522. 

  522.             }
    523. 

  523.         }
    524. 

  524. 

  525.         #endregion
    526. 

  526.     }
    527. 

  527. }
    528.