ValueSetExtensionsTests.cs (16688B)
1 // ----------------------------------------------------------------------------- 2 // <copyright file="ValueSetExtensionsTests.cs" company="Microsoft Corporation"> 3 // Copyright (c) Microsoft Corporation. Licensed under the MIT License. 4 // </copyright> 5 // ----------------------------------------------------------------------------- 6 7 namespace Microsoft.Management.Configuration.UnitTests.Tests 8 { 9 using System; 10 using System.Collections; 11 using System.Collections.Generic; 12 using Microsoft.Management.Configuration.Processor.Extensions; 13 using Microsoft.Management.Configuration.UnitTests.Fixtures; 14 using Microsoft.Management.Configuration.UnitTests.Helpers; 15 using Windows.Foundation.Collections; 16 using Xunit; 17 using Xunit.Abstractions; 18 19 /// <summary> 20 /// ValueSet extension tests. 21 /// </summary> 22 [Collection("UnitTestCollection")] 23 [InProc] 24 public class ValueSetExtensionsTests 25 { 26 private readonly UnitTestFixture fixture; 27 private readonly ITestOutputHelper log; 28 29 /// <summary> 30 /// Initializes a new instance of the <see cref="ValueSetExtensionsTests"/> class. 31 /// </summary> 32 /// <param name="fixture">Unit test fixture.</param> 33 /// <param name="log">Log helper.</param> 34 public ValueSetExtensionsTests(UnitTestFixture fixture, ITestOutputHelper log) 35 { 36 this.fixture = fixture; 37 this.log = log; 38 } 39 40 /// <summary> 41 /// Tests PropertyExists. 42 /// </summary> 43 [Fact] 44 public void ValueSet_SimpleTypes() 45 { 46 string stringProperty = "stringProperty"; 47 string stringPropertyValue = "string"; 48 49 string intProperty = "intProperty"; 50 long intPropertyValue = 64; 51 52 string boolProperty = "boolProperty"; 53 bool boolPropertyValue = true; 54 55 var valueSet = new ValueSet 56 { 57 { stringProperty, stringPropertyValue }, 58 { intProperty, intPropertyValue }, 59 { boolProperty, boolPropertyValue }, 60 }; 61 62 var resultHashtable = valueSet.ToHashtable(); 63 64 Assert.NotNull(resultHashtable); 65 66 Assert.True(resultHashtable.ContainsKey(stringProperty)); 67 Assert.Equal(stringPropertyValue, resultHashtable[stringProperty]); 68 69 Assert.True(resultHashtable.ContainsKey(intProperty)); 70 Assert.Equal(intPropertyValue, resultHashtable[intProperty]); 71 72 Assert.True(resultHashtable.ContainsKey(boolProperty)); 73 Assert.Equal(boolPropertyValue, resultHashtable[boolProperty]); 74 } 75 76 /// <summary> 77 /// Tests when a ValueSet has inner value sets. 78 /// </summary> 79 [Fact] 80 public void ValueSet_NestedValueSets() 81 { 82 string boolPropertyInner = "boolPropertyInner"; 83 bool boolPropertyValueInner = true; 84 var valueSetInner = new ValueSet() 85 { 86 { boolPropertyInner, boolPropertyValueInner }, 87 }; 88 89 string stringPropertyInnerInner = "stringPropertyInnerInner"; 90 string stringPropertyValueInnerInner = "stringInnerInner"; 91 var valueSetInnerInner = new ValueSet() 92 { 93 { stringPropertyInnerInner, stringPropertyValueInnerInner }, 94 }; 95 96 string inner2Key = "InnerKey2"; 97 var valueSetInner2 = new ValueSet() 98 { 99 { inner2Key, valueSetInnerInner }, 100 }; 101 102 string key1 = "key1"; 103 string key2 = "key2"; 104 var valueSet = new ValueSet() 105 { 106 { key1, valueSetInner }, 107 { key2, valueSetInner2 }, 108 }; 109 110 var hashtable = valueSet.ToHashtable(); 111 Assert.NotNull(hashtable); 112 Assert.Equal(2, hashtable.Count); 113 Assert.True(hashtable.ContainsKey(key1)); 114 Assert.True(hashtable.ContainsKey(key2)); 115 116 var key1Result = hashtable[key1] as Hashtable; 117 Assert.NotNull(key1Result); 118 Assert.Single(key1Result); 119 Assert.True(key1Result.ContainsKey(boolPropertyInner)); 120 Assert.Equal(boolPropertyValueInner, key1Result[boolPropertyInner]); 121 122 var key2Result = hashtable[key2] as Hashtable; 123 Assert.NotNull(key2Result); 124 Assert.Single(key2Result); 125 Assert.True(key2Result.ContainsKey(inner2Key)); 126 var key2ResultInner = key2Result[inner2Key] as Hashtable; 127 Assert.NotNull(key2ResultInner); 128 Assert.True(key2ResultInner.ContainsKey(stringPropertyInnerInner)); 129 Assert.Equal(stringPropertyValueInnerInner, key2ResultInner[stringPropertyInnerInner]); 130 } 131 132 /// <summary> 133 /// Test when ValueSet contains a ValueSet that is threated as an. 134 /// </summary> 135 [Fact] 136 public void ValueSet_ArraySimpleTypes() 137 { 138 var valueSetArray = new ValueSet() 139 { 140 { "treatAsArray", true }, 141 { "0", "value1" }, 142 { "1", "value1" }, 143 { "2", "value1" }, 144 { "3", "value1" }, 145 }; 146 147 string arrayKey = "arrayKey"; 148 var valueSet = new ValueSet() 149 { 150 { arrayKey, valueSetArray }, 151 }; 152 153 var hashtable = valueSet.ToHashtable(); 154 Assert.NotNull(hashtable); 155 Assert.True(hashtable.ContainsKey(arrayKey)); 156 157 var expectedList = hashtable[arrayKey] as IList<object>; 158 Assert.NotNull(expectedList); 159 Assert.Equal(4, expectedList.Count); 160 foreach (var element in expectedList) 161 { 162 Assert.IsType<string>(element); 163 } 164 } 165 166 /// <summary> 167 /// Test ValueSet with an array of value sets. 168 /// </summary> 169 [Fact] 170 public void ValueSet_ArrayHashtable() 171 { 172 var arrayValue1 = new ValueSet() 173 { 174 { "key11", "value11" }, 175 { "key12", "value12" }, 176 }; 177 178 var arrayValue2 = new ValueSet() 179 { 180 { "key21", "value21" }, 181 }; 182 183 var valueSetArray = new ValueSet() 184 { 185 { "treatAsArray", true }, 186 { "0", arrayValue1 }, 187 { "1", arrayValue2 }, 188 }; 189 190 string arrayKey = "arrayKey"; 191 var valueSet = new ValueSet() 192 { 193 { arrayKey, valueSetArray }, 194 }; 195 196 var hashtable = valueSet.ToHashtable(); 197 Assert.NotNull(hashtable); 198 Assert.True(hashtable.ContainsKey(arrayKey)); 199 200 var expectedList = hashtable[arrayKey] as IList<object>; 201 Assert.NotNull(expectedList); 202 Assert.Equal(2, expectedList.Count); 203 204 var resultValue1 = expectedList[0] as Hashtable; 205 Assert.NotNull(resultValue1); 206 Assert.Equal(2, resultValue1.Count); 207 208 var resultValue2 = expectedList[1] as Hashtable; 209 Assert.NotNull(resultValue2); 210 Assert.Single(resultValue2); 211 } 212 213 /// <summary> 214 /// Tests ConvertValueSetToArray. 215 /// </summary> 216 [Fact] 217 public void ValueSet_ArrayOrder() 218 { 219 string arrayValue0 = "arrayValue0"; 220 string arrayValue1 = "arrayValue1"; 221 string arrayValue2 = "arrayValue2"; 222 string arrayValue3 = "arrayValue3"; 223 string arrayValue4 = "arrayValue4"; 224 string arrayValue5 = "arrayValue5"; 225 string arrayValue6 = "arrayValue6"; 226 string arrayValue7 = "arrayValue7"; 227 string arrayValue8 = "arrayValue8"; 228 string arrayValue9 = "arrayValue9"; 229 string arrayValue10 = "arrayValue10"; 230 string arrayValue11 = "arrayValue11"; 231 string arrayValue12 = "arrayValue12"; 232 var valueSetArray = new ValueSet() 233 { 234 { "10", arrayValue10 }, 235 { "7", arrayValue7 }, 236 { "2", arrayValue2 }, 237 { "12", arrayValue12 }, 238 { "6", arrayValue6 }, 239 { "treatAsArray", true }, 240 { "3", arrayValue3 }, 241 { "1", arrayValue1 }, 242 { "9", arrayValue9 }, 243 { "0", arrayValue0 }, 244 { "4", arrayValue4 }, 245 { "11", arrayValue11 }, 246 { "8", arrayValue8 }, 247 { "5", arrayValue5 }, 248 }; 249 250 var result = valueSetArray.ToArray(); 251 Assert.NotNull(result); 252 Assert.Equal(valueSetArray.Count - 1, result.Count); 253 Assert.Equal(arrayValue0, result[0]); 254 Assert.Equal(arrayValue1, result[1]); 255 Assert.Equal(arrayValue2, result[2]); 256 Assert.Equal(arrayValue3, result[3]); 257 Assert.Equal(arrayValue4, result[4]); 258 Assert.Equal(arrayValue5, result[5]); 259 Assert.Equal(arrayValue6, result[6]); 260 Assert.Equal(arrayValue7, result[7]); 261 Assert.Equal(arrayValue8, result[8]); 262 Assert.Equal(arrayValue9, result[9]); 263 Assert.Equal(arrayValue10, result[10]); 264 Assert.Equal(arrayValue11, result[11]); 265 Assert.Equal(arrayValue12, result[12]); 266 } 267 268 /// <summary> 269 /// Tests ConvertValueSetToArray. 270 /// </summary> 271 [Fact] 272 public void ValueSet_InvalidArray() 273 { 274 string arrayValue0 = "arrayValue0"; 275 string arrayValue1 = "arrayValue1"; 276 string arrayValue2 = "arrayValue2"; 277 string arrayValue3 = "arrayValue3"; 278 string arrayValue4 = "arrayValue4"; 279 string arrayValue5 = "arrayValue5"; 280 string arrayValue6 = "arrayValue6"; 281 string arrayValue7 = "arrayValue7"; 282 string arrayValue8 = "arrayValue8"; 283 string arrayValue9 = "arrayValue9"; 284 string arrayValue10 = "arrayValue10"; 285 string arrayValue11 = "arrayValue11"; 286 string arrayValue12 = "arrayValue12"; 287 var valueSetArray = new ValueSet() 288 { 289 { "10", arrayValue10 }, 290 { "7", arrayValue7 }, 291 { "2", arrayValue2 }, 292 { "12", arrayValue12 }, 293 { "6", arrayValue6 }, 294 { "3", arrayValue3 }, 295 { "1", arrayValue1 }, 296 { "9", arrayValue9 }, 297 { "0", arrayValue0 }, 298 { "4", arrayValue4 }, 299 { "11", arrayValue11 }, 300 { "8", arrayValue8 }, 301 { "5", arrayValue5 }, 302 }; 303 304 Assert.Throws<InvalidOperationException>(() => valueSetArray.ToArray()); 305 } 306 307 /// <summary> 308 /// Tests ConvertValueSetToArray. 309 /// </summary> 310 [Fact] 311 public void ValueSet_InvalidArrayKey() 312 { 313 string arrayValue0 = "arrayValue0"; 314 string arrayValue1 = "arrayValue1"; 315 string arrayValue2 = "arrayValue2"; 316 string arrayValue3 = "arrayValue3"; 317 string arrayValue4 = "arrayValue4"; 318 string arrayValue5 = "arrayValue5"; 319 string arrayValue6 = "arrayValue6"; 320 string arrayValue7 = "arrayValue7"; 321 string arrayValue8 = "arrayValue8"; 322 string arrayValue9 = "arrayValue9"; 323 string arrayValue10 = "arrayValue10"; 324 string arrayValue11 = "arrayValue11"; 325 string arrayValue12 = "arrayValue12"; 326 var valueSetArray = new ValueSet() 327 { 328 { "10", arrayValue10 }, 329 { "7", arrayValue7 }, 330 { "2", arrayValue2 }, 331 { "a", arrayValue12 }, 332 { "6", arrayValue6 }, 333 { "3", arrayValue3 }, 334 { "1", arrayValue1 }, 335 { "9", arrayValue9 }, 336 { "0", arrayValue0 }, 337 { "4", arrayValue4 }, 338 { "11", arrayValue11 }, 339 { "8", arrayValue8 }, 340 { "5", arrayValue5 }, 341 }; 342 343 Assert.Throws<InvalidOperationException>(() => valueSetArray.ToArray()); 344 } 345 346 /// <summary> 347 /// Tests ValueSet simple types content equals. 348 /// </summary> 349 [Fact] 350 public void ValueSet_SimpleTypes_ContentEquals() 351 { 352 string stringProperty = "stringProperty"; 353 string stringPropertyValue = "string"; 354 355 string intProperty = "intProperty"; 356 long intPropertyValue = 64; 357 358 string boolProperty = "boolProperty"; 359 bool boolPropertyValue = true; 360 361 var valueSet = new ValueSet 362 { 363 { stringProperty, stringPropertyValue }, 364 { intProperty, intPropertyValue }, 365 { boolProperty, boolPropertyValue }, 366 }; 367 368 // Same content different order 369 var valueSetDifferentOrder = new ValueSet 370 { 371 { boolProperty, boolPropertyValue }, 372 { stringProperty, stringPropertyValue }, 373 { intProperty, intPropertyValue }, 374 }; 375 376 Assert.True(valueSet.ContentEquals(valueSetDifferentOrder)); 377 378 // Entry missing 379 var valueSetEntryMissing = new ValueSet 380 { 381 { stringProperty, stringPropertyValue }, 382 { intProperty, intPropertyValue }, 383 }; 384 385 Assert.False(valueSet.ContentEquals(valueSetEntryMissing)); 386 387 // Different entry 388 var valueSetEntryDifferent = new ValueSet 389 { 390 { stringProperty, stringPropertyValue }, 391 { intProperty, intPropertyValue }, 392 { "Another", "AnotherValue" }, 393 }; 394 395 Assert.False(valueSet.ContentEquals(valueSetEntryDifferent)); 396 397 // Different value 398 var valueSetDifferentValue = new ValueSet 399 { 400 { boolProperty, boolPropertyValue }, 401 { stringProperty, stringPropertyValue }, 402 { intProperty, 0 }, 403 }; 404 405 Assert.False(valueSet.ContentEquals(valueSetDifferentValue)); 406 } 407 408 /// <summary> 409 /// Tests when a ValueSet has inner value sets. 410 /// </summary> 411 [Fact] 412 public void ValueSet_NestedValueSets_ContentEquals() 413 { 414 string boolPropertyInner = "boolPropertyInner"; 415 bool boolPropertyValueInner = true; 416 var valueSetInner = new ValueSet() 417 { 418 { boolPropertyInner, boolPropertyValueInner }, 419 }; 420 421 string stringPropertyInnerInner = "stringPropertyInnerInner"; 422 string stringPropertyValueInnerInner = "stringInnerInner"; 423 var valueSetInnerInner = new ValueSet() 424 { 425 { stringPropertyInnerInner, stringPropertyValueInnerInner }, 426 }; 427 428 string inner2Key = "InnerKey2"; 429 var valueSetInner2 = new ValueSet() 430 { 431 { inner2Key, valueSetInnerInner }, 432 }; 433 434 string key1 = "key1"; 435 string key2 = "key2"; 436 var valueSet = new ValueSet() 437 { 438 { key1, valueSetInner }, 439 { key2, valueSetInner2 }, 440 }; 441 442 // Same content different order 443 var valueSetDifferentOrder = new ValueSet() 444 { 445 { key2, valueSetInner2 }, 446 { key1, valueSetInner }, 447 }; 448 449 Assert.True(valueSet.ContentEquals(valueSetDifferentOrder)); 450 451 // Different nested content 452 var valueSetDifferentContent = new ValueSet() 453 { 454 { key2, valueSetInner }, 455 { key1, valueSetInner2 }, 456 }; 457 458 Assert.False(valueSet.ContentEquals(valueSetDifferentContent)); 459 } 460 } 461 }