PageRenderTime 63ms CodeModel.GetById 17ms RepoModel.GetById 0ms app.codeStats 0ms

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

https://bitbucket.org/mdavid/aspnetwebstack
C# | 503 lines | 451 code | 27 blank | 25 comment | 1 complexity | e515f14fbfec150e9101ee12ce298918 MD5 | raw file
    

  1. using System.Collections.Generic;
    2. 

  2. using System.Json;
    3. 

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

  4. using System.Text;
    5. 

  5. using Newtonsoft.Json.Linq;
    6. 

  6. using Xunit;
    7. 

  7. using Xunit.Extensions;
    8. 

  8. 

  9. namespace System.Net.Http.Formatting
    10. 

  10. {
    11. 

  11.     public class FormUrlEncodedJsonFromUriQueryTests
    12. 

  12.     {
    13. 

  13.         #region Tests
    14. 

  14. 

  15.         [Theory,
    16. 

  16.             InlineData("abc", "{\"abc\":\"\"}"),
    17. 

  17.             InlineData("%2eabc%2e", "{\".abc.\":\"\"}"),
    18. 

  18.             InlineData("", "{}"),
    19. 

  19.             InlineData("a=1", "{\"a\":\"1\"}")]
    20. 

  20.         public void SimpleStringsTest(string encoded, string expectedResult)
    21. 

  21.         {
    22. 

  22.             ValidateFormUrlEncoded(encoded, expectedResult);
    23. 

  23.         }
    24. 

  24. 

  25.         [Theory,
    26. 

  26.             InlineData("a=2", "{\"a\":\"2\"}"),
    27. 

  27.             InlineData("b=true", "{\"b\":\"true\"}"),
    28. 

  28.             InlineData("c=hello", "{\"c\":\"hello\"}"),
    29. 

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

  30.             InlineData("e=null", "{\"e\":\"null\"}")]
    31. 

  31.         public void SimpleObjectsTest(string encoded, string expectedResult)
    32. 

  32.         {
    33. 

  33.             ValidateFormUrlEncoded(encoded, expectedResult);
    34. 

  34.         }
    35. 

  35. 

  36.         [Fact]
    37. 

  37.         public void LegacyArraysTest()
    38. 

  38.         {
    39. 

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

  40. 

  41.             // Only valid in shallow serialization
    42. 

  42.             ParseInvalidFormUrlEncoded("a[z]=2&a[z]=3");
    43. 

  43.         }
    44. 

  44. 

  45.         [Theory,
    46. 

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

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

  48.             InlineData("a[]=", "{\"a\":[\"\"]}"),
    49. 

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

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

  51.         public void ArraysTest(string encoded, string expectedResult)
    52. 

  52.         {
    53. 

  53.             ValidateFormUrlEncoded(encoded, expectedResult);
    54. 

  54.         }
    55. 

  55. 

  56.         [Theory,
    57. 

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

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

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

  60.         public void MultidimensionalArraysTest(string encoded, string expectedResult)
    61. 

  61.         {
    62. 

  62.             ValidateFormUrlEncoded(encoded, expectedResult);
    63. 

  63.         }
    64. 

  64. 

  65.         [Theory,
    66. 

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

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

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

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

  70.         public void SparseArraysTest(string encoded, string expectedResult)
    71. 

  71.         {
    72. 

  72.             ValidateFormUrlEncoded(encoded, expectedResult);
    73. 

  73.         }
    74. 

  74. 

  75.         [Theory,
    76. 

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

  77.         public void ArraysWithMixedMembers(string encoded, string expectedResult)
    78. 

  78.         {
    79. 

  79.             ValidateFormUrlEncoded(encoded, expectedResult);
    80. 

  80.         }
    81. 

  81. 

  82.         [Theory,
    83. 

  83.             InlineData("=3", "{\"\":\"3\"}"),
    84. 

  84.             InlineData("a=1&=3", "{\"a\":\"1\",\"\":\"3\"}"),
    85. 

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

  86.         public void EmptyKeyTest(string encoded, string expectedResult)
    87. 

  87.         {
    88. 

  88.             ValidateFormUrlEncoded(encoded, expectedResult);
    89. 

  89.         }
    90. 

  90. 

  91.         [Theory,
    92. 

  92.             InlineData("a[b]=1&a=2"),
    93. 

  93.             InlineData("a[b]=1&a[b][]=2"),
    94. 

  94.             InlineData("a[x][]=1&a[x][0]=2"),
    95. 

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

  96.             InlineData("[]=1"),
    97. 

  97.             InlineData("a[][]=0"),
    98. 

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

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

  100.         public void InvalidObjectGraphsTest(string encoded)
    101. 

  101.         {
    102. 

  102.             ParseInvalidFormUrlEncoded(encoded);
    103. 

  103.         }
    104. 

  104. 

  105.         [Theory,
    106. 

  106.             InlineData("a[b=2"),
    107. 

  107.             InlineData("a[[b]=2"),
    108. 

  108.             InlineData("a[b]]=2")]
    109. 

  109.         public void InvalidFormUrlEncodingTest(string encoded)
    110. 

  110.         {
    111. 

  111.             ParseInvalidFormUrlEncoded(encoded);
    112. 

  112.         }
    113. 

  113. 

  114.         /// <summary>
    115. 

  115.         /// Tests for parsing form-urlencoded data originated from JS primitives.
    116. 

  116.         /// </summary>
    117. 

  117.         [Theory,
    118. 

  118.             InlineData("abc", @"{""abc"":""""}"),
    119. 

  119.             InlineData("123", @"{""123"":""""}"),
    120. 

  120.             InlineData("true", @"{""true"":""""}"),
    121. 

  121.             InlineData("", "{}"),
    122. 

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

  123.         public void TestJValue(string encoded, string expectedResult)
    124. 

  124.         {
    125. 

  125.             ValidateFormUrlEncoded(encoded, expectedResult);
    126. 

  126.         }
    127. 

  127. 

  128.         /// <summary>
    129. 

  129.         /// Negative tests for parsing form-urlencoded data originated from JS primitives.
    130. 

  130.         /// </summary>
    131. 

  131.         [Theory,
    132. 

  132.             InlineData("a[b]=1&a=2"),
    133. 

  133.             InlineData("a=2&a[b]=1"),
    134. 

  134.             InlineData("[]=1")]
    135. 

  135.         public void TestJValueNegative(string encoded)
    136. 

  136.         {
    137. 

  137.             ParseInvalidFormUrlEncoded(encoded);
    138. 

  138.         }
    139. 

  139. 

  140.         /// <summary>
    141. 

  141.         /// Tests for parsing form-urlencoded data originated from JS objects.
    142. 

  142.         /// </summary>
    143. 

  143.         [Theory,
    144. 

  144.             InlineData("a=NaN", @"{""a"":""NaN""}"),
    145. 

  145.             InlineData("a=false", @"{""a"":""false""}"),
    146. 

  146.             InlineData("a=foo", @"{""a"":""foo""}"),
    147. 

  147.             InlineData("1=1", "{\"1\":\"1\"}")]
    148. 

  148.         public void TestObjects(string encoded, string expectedResult)
    149. 

  149.         {
    150. 

  150.             ValidateFormUrlEncoded(encoded, expectedResult);
    151. 

  151.         }
    152. 

  152. 

  153.         /// <summary>
    154. 

  154.         /// Tests for parsing form-urlencoded data originated from JS arrays.
    155. 

  155.         /// </summary>
    156. 

  156.         [Theory,
    157. 

  157.             InlineData("a[]=2", @"{""a"":[""2""]}"),
    158. 

  158.             InlineData("a[]=", @"{""a"":[""""]}"),
    159. 

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

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

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

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

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

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

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

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

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

  168.             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""]]}")]
    169. 

  169.         public void TestArray(string encoded, string expectedResult)
    170. 

  170.         {
    171. 

  171.             ValidateFormUrlEncoded(encoded, expectedResult);
    172. 

  172.         }
    173. 

  173. 

  174.         /// <summary>
    175. 

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

  176.         /// </summary>
    177. 

  177.         [Theory,
    178. 

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

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

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

  181.         public void TestArrayCompat(string encoded, string expectedResult)
    182. 

  182.         {
    183. 

  183.             ValidateFormUrlEncoded(encoded, expectedResult);
    184. 

  184.         }
    185. 

  185. 

  186.         /// <summary>
    187. 

  187.         /// Negative tests for parsing form-urlencoded data originated from JS arrays.
    188. 

  188.         /// </summary>
    189. 

  189.         [Theory,
    190. 

  190.             InlineData("a[z]=2&a[z]=3")]
    191. 

  191.         public void TestArrayCompatNegative(string encoded)
    192. 

  192.         {
    193. 

  193.             ParseInvalidFormUrlEncoded(encoded);
    194. 

  194.         }
    195. 

  195. 

  196.         /// <summary>
    197. 

  197.         /// Tests for form-urlencoded data originated from sparse JS arrays.
    198. 

  198.         /// </summary>
    199. 

  199.         [Theory,
    200. 

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

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

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

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

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

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

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

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

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

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

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

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

  212.         public void TestArraySparse(string encoded, string expectedResult)
    213. 

  213.         {
    214. 

  214.             ValidateFormUrlEncoded(encoded, expectedResult);
    215. 

  215.         }
    216. 

  216. 

  217.         /// <summary>
    218. 

  218.         /// Negative tests for parsing form-urlencoded arrays.
    219. 

  219.         /// </summary>
    220. 

  220.         [Theory,
    221. 

  221.             InlineData("a[x]=2&a[x][]=3"),
    222. 

  222.             InlineData("a[]=1&a[0][]=2"),
    223. 

  223.             InlineData("a[]=1&a[0][0][]=2"),
    224. 

  224.             InlineData("a[x][]=1&a[x][0]=2"),
    225. 

  225.             InlineData("a[][]=0"),
    226. 

  226.             InlineData("a[][x]=0")]
    227. 

  227.         public void TestArrayIndexNegative(string encoded)
    228. 

  228.         {
    229. 

  229.             ParseInvalidFormUrlEncoded(encoded);
    230. 

  230.         }
    231. 

  231. 

  232. 

  233.         public static IEnumerable<object[]> TestObjectPropertyData
    234. 

  234.         {
    235. 

  235.             get
    236. 

  236.             {
    237. 

  237.                 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=";
    238. 

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

  239.                 yield return new[] { encoded, resultStr };
    240. 

  240. 

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

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

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

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

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

  246.                 yield return new[] { encoded, resultStr };
    247. 

  247. 

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

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

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

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

  252.                     "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";
    253. 

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

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

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

  256.                 yield return new[] { encoded, resultStr };
    257. 

  257. 

  258.                 encoded = "ab%5B%5D=hello";
    259. 

  259.                 resultStr = @"{""ab"":[""hello""]}";
    260. 

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

  261. 

  262.                 encoded = "123=hello";
    263. 

  263.                 resultStr = @"{""123"":""hello""}";
    264. 

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

  265. 

  266.                 encoded = "a%5B%5D=1&a";
    267. 

  267.                 resultStr = @"{""a"":[""1"",""""]}";
    268. 

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

  269. 

  270.                 encoded = "a=1&a";
    271. 

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

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

  273.             }
    274. 

  274.         }
    275. 

  275. 

  276.         /// <summary>
    277. 

  277.         /// Tests for parsing complex object graphs form-urlencoded.
    278. 

  278.         /// </summary>
    279. 

  279.         [Theory]
    280. 

  280.         [PropertyData("TestObjectPropertyData")]
    281. 

  281.         public void TestObject(string encoded, string expectedResult)
    282. 

  282.         {
    283. 

  283.             ValidateFormUrlEncoded(encoded, expectedResult);
    284. 

  284.         }
    285. 

  285. 

  286.         public static IEnumerable<object[]> TestEncodedNameTestData
    287. 

  287.         {
    288. 

  288.             get
    289. 

  289.             {
    290. 

  290.                 string encoded = "some+thing=10";
    291. 

  291.                 string resultStr = @"{""some thing"":""10""}";
    292. 

  292.                 yield return new[] { encoded, resultStr };
    293. 

  293. 

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

  295.                 resultStr = @"{""带三个表"":""bar""}";
    296. 

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

  297. 

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

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

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

  301. 

  302.                 encoded = "a[0\r\n][b]=1";
    303. 

  303.                 resultStr = "{\"a\":{\"0\\r\\n\":{\"b\":\"1\"}}}";
    304. 

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

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

  306. 

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

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

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

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

  311.             }
    312. 

  312.         }
    313. 

  313. 

  314.         /// <summary>
    315. 

  315.         /// Tests for parsing form-urlencoded data with encoded names.
    316. 

  316.         /// </summary>
    317. 

  317.         [Theory]
    318. 

  318.         [PropertyData("TestEncodedNameTestData")]
    319. 

  319.         public void TestEncodedName(string encoded, string expectedResult)
    320. 

  320.         {
    321. 

  321.             ValidateFormUrlEncoded(encoded, expectedResult);
    322. 

  322.         }
    323. 

  323. 

  324.         /// <summary>
    325. 

  325.         /// Tests for malformed form-urlencoded data.
    326. 

  326.         /// </summary>
    327. 

  327.         [Theory,
    328. 

  328.             InlineData("a[b=2"),
    329. 

  329.             InlineData("a[[b]=2"),
    330. 

  330.             InlineData("a[b]]=2")]
    331. 

  331.         public void TestNegative(string encoded)
    332. 

  332.         {
    333. 

  333.             ParseInvalidFormUrlEncoded(encoded);
    334. 

  334.         }
    335. 

  335. 

  336.         /// <summary>
    337. 

  337.         /// Tests for parsing generated form-urlencoded data.
    338. 

  338.         /// </summary>
    339. 

  339.         [Fact]
    340. 

  340.         public void GeneratedJTokenTest()
    341. 

  341.         {
    342. 

  342.             Random rndGen = new Random(1);
    343. 

  343.             int oldMaxArray = CreatorSettings.MaxArrayLength;
    344. 

  344.             int oldMaxList = CreatorSettings.MaxListLength;
    345. 

  345.             int oldMaxStr = CreatorSettings.MaxStringLength;
    346. 

  346.             double oldNullProbability = CreatorSettings.NullValueProbability;
    347. 

  347.             bool oldCreateAscii = CreatorSettings.CreateOnlyAsciiChars;
    348. 

  348.             CreatorSettings.MaxArrayLength = 5;
    349. 

  349.             CreatorSettings.MaxListLength = 3;
    350. 

  350.             CreatorSettings.MaxStringLength = 3;
    351. 

  351.             CreatorSettings.NullValueProbability = 0;
    352. 

  352.             CreatorSettings.CreateOnlyAsciiChars = true;
    353. 

  353.             JTokenCreatorSurrogate jsonValueCreator = new JTokenCreatorSurrogate();
    354. 

  354.             try
    355. 

  355.             {
    356. 

  356.                 for (int i = 0; i < 1000; i++)
    357. 

  357.                 {
    358. 

  358.                     JToken jv = (JToken)jsonValueCreator.CreateInstanceOf(typeof(JToken), rndGen);
    359. 

  359.                     if (jv.Type == JTokenType.Array || jv.Type == JTokenType.Object)
    360. 

  360.                     {
    361. 

  361.                         string jaStr = FormUrlEncoding(jv);
    362. 

  362.                         JToken deserJv = ParseFormUrlEncoded(jaStr);
    363. 

  363.                         bool compare = true;
    364. 

  364.                         if (deserJv is JObject && ((IDictionary<string, JToken>)deserJv).ContainsKey("JV"))
    365. 

  365.                         {
    366. 

  366.                             compare = JTokenRoundTripComparer.Compare(jv, deserJv["JV"]);
    367. 

  367.                         }
    368. 

  368.                         else
    369. 

  369.                         {
    370. 

  370.                             compare = JTokenRoundTripComparer.Compare(jv, deserJv);
    371. 

  371.                         }
    372. 

  372. 

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

  374.                     }
    375. 

  375.                 }
    376. 

  376.             }
    377. 

  377.             finally
    378. 

  378.             {
    379. 

  379.                 CreatorSettings.MaxArrayLength = oldMaxArray;
    380. 

  380.                 CreatorSettings.MaxListLength = oldMaxList;
    381. 

  381.                 CreatorSettings.MaxStringLength = oldMaxStr;
    382. 

  382.                 CreatorSettings.NullValueProbability = oldNullProbability;
    383. 

  383.                 CreatorSettings.CreateOnlyAsciiChars = oldCreateAscii;
    384. 

  384.             }
    385. 

  385.         }
    386. 

  386. 

  387.         #endregion
    388. 

  388. 

  389.         #region Helpers
    390. 

  390.         private static string FormUrlEncoding(JToken jsonValue)
    391. 

  391.         {
    392. 

  392.             List<string> results = new List<string>();
    393. 

  393.             if (jsonValue is JValue)
    394. 

  394.             {
    395. 

  395.                 return UriQueryUtility.UrlEncode(((JValue)jsonValue).Value.ToString());
    396. 

  396.             }
    397. 

  397. 

  398.             BuildParams("JV", jsonValue, results);
    399. 

  399.             StringBuilder strResult = new StringBuilder();
    400. 

  400.             foreach (var result in results)
    401. 

  401.             {
    402. 

  402.                 strResult.Append("&" + result);
    403. 

  403.             }
    404. 

  404. 

  405.             if (strResult.Length > 0)
    406. 

  406.             {
    407. 

  407.                 return strResult.Remove(0, 1).ToString();
    408. 

  408.             }
    409. 

  409. 

  410.             return strResult.ToString();
    411. 

  411.         }
    412. 

  412. 

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

  414.         {
    415. 

  415.             if (jsonValue is JValue)
    416. 

  416.             {
    417. 

  417.                 JValue jsonPrimitive = jsonValue as JValue;
    418. 

  418.                 if (jsonPrimitive != null)
    419. 

  419.                 {
    420. 

  420.                     if (jsonPrimitive.Type == JTokenType.String && String.IsNullOrEmpty(jsonPrimitive.Value.ToString()))
    421. 

  421.                     {
    422. 

  422.                         results.Add(prefix + "=" + String.Empty);
    423. 

  423.                     }
    424. 

  424.                     else
    425. 

  425.                     {
    426. 

  426.                         if (jsonPrimitive.Value is DateTime || jsonPrimitive.Value is DateTimeOffset)
    427. 

  427.                         {
    428. 

  428.                             string dateStr = jsonPrimitive.ToString();
    429. 

  429.                             if (!String.IsNullOrEmpty(dateStr) && dateStr.StartsWith("\""))
    430. 

  430.                             {
    431. 

  431.                                 dateStr = dateStr.Substring(1, dateStr.Length - 2);
    432. 

  432.                             }
    433. 

  433.                             results.Add(prefix + "=" + UriQueryUtility.UrlEncode(dateStr));
    434. 

  434.                         }
    435. 

  435.                         else
    436. 

  436.                         {
    437. 

  437.                             results.Add(prefix + "=" + UriQueryUtility.UrlEncode(jsonPrimitive.Value.ToString()));
    438. 

  438.                         }
    439. 

  439.                     }
    440. 

  440.                 }
    441. 

  441.                 else
    442. 

  442.                 {
    443. 

  443.                     results.Add(prefix + "=" + String.Empty);
    444. 

  444.                 }
    445. 

  445.             }
    446. 

  446.             else if (jsonValue is JArray)
    447. 

  447.             {
    448. 

  448.                 for (int i = 0; i < ((JArray)jsonValue).Count; i++)
    449. 

  449.                 {
    450. 

  450.                     if (jsonValue[i] is JArray || jsonValue[i] is JObject)
    451. 

  451.                     {
    452. 

  452.                         BuildParams(prefix + "[" + i + "]", jsonValue[i], results);
    453. 

  453.                     }
    454. 

  454.                     else
    455. 

  455.                     {
    456. 

  456.                         BuildParams(prefix + "[]", jsonValue[i], results);
    457. 

  457.                     }
    458. 

  458.                 }
    459. 

  459.             }
    460. 

  460.             else //jsonValue is JObject
    461. 

  461.             {
    462. 

  462.                 foreach (KeyValuePair<string, JToken> item in (JObject)jsonValue)
    463. 

  463.                 {
    464. 

  464.                     BuildParams(prefix + "[" + item.Key + "]", item.Value, results);
    465. 

  465.                 }
    466. 

  466.             }
    467. 

  467.         }
    468. 

  468. 

  469.         private static Uri GetQueryUri(string query)
    470. 

  470.         {
    471. 

  471.             UriBuilder uriBuilder = new UriBuilder("http://some.host");
    472. 

  472.             uriBuilder.Query = query;
    473. 

  473.             return uriBuilder.Uri;
    474. 

  474.         }
    475. 

  475. 

  476.         private static JToken ParseFormUrlEncoded(string encoded)
    477. 

  477.         {
    478. 

  478.             Uri address = GetQueryUri(encoded);
    479. 

  479.             JObject result;
    480. 

  480.             Assert.True(address.TryReadQueryAsJson(out result), "Expected parsing to return true");
    481. 

  481.             return result;
    482. 

  482.         }
    483. 

  483. 

  484.         private static void ParseInvalidFormUrlEncoded(string encoded)
    485. 

  485.         {
    486. 

  486.             Uri address = GetQueryUri(encoded);
    487. 

  487.             JObject result;
    488. 

  488.             Assert.False(address.TryReadQueryAsJson(out result), "Expected parsing to return false");
    489. 

  489.             Assert.Null(result);
    490. 

  490.         }
    491. 

  491. 

  492.         private static void ValidateFormUrlEncoded(string encoded, string expectedResult)
    493. 

  493.         {
    494. 

  494.             Uri address = GetQueryUri(encoded);
    495. 

  495.             JObject result;
    496. 

  496.             Assert.True(address.TryReadQueryAsJson(out result), "Expected parsing to return true");
    497. 

  497.             Assert.NotNull(result);
    498. 

  498.             Assert.Equal(expectedResult, result.ToString(Newtonsoft.Json.Formatting.None));
    499. 

  499.         }
    500. 

  500. 

  501.         #endregion
    502. 

  502.     }
    503. 

  503. }
    504.