[{"data":1,"prerenderedAt":1925},["ShallowReactive",2],{"docs-navigation":3,"api-catalog":188,"api-nav-empty":286,"docs:\u002Fdocs\u002Fextensions\u002Fidioms":287,"docs:\u002Fdocs\u002Fextensions\u002Fidioms-surround":1922},[4],{"title":5,"path":6,"stem":7,"children":8,"page":32},"Docs","\u002Fdocs","docs",[9,33,63,85,99,137,154],{"title":10,"badge":11,"icon":12,"path":13,"stem":14,"children":15,"page":32},"Get started",null,"i-lucide-rocket","\u002Fdocs\u002Fget-started","docs\u002F1.get-started",[16,20,24,28],{"title":17,"path":18,"stem":19,"badge":11},"Introduction","\u002Fdocs\u002Fget-started\u002Fintroduction","docs\u002F1.get-started\u002F1.introduction",{"title":21,"path":22,"stem":23,"badge":11},"Installation","\u002Fdocs\u002Fget-started\u002Finstallation","docs\u002F1.get-started\u002F2.installation",{"title":25,"path":26,"stem":27,"badge":11},"Your first test","\u002Fdocs\u002Fget-started\u002Ffirst-test","docs\u002F1.get-started\u002F3.first-test",{"title":29,"path":30,"stem":31,"badge":11},"Refactoring a test","\u002Fdocs\u002Fget-started\u002Frefactoring-a-test","docs\u002F1.get-started\u002F4.refactoring-a-test",false,{"title":34,"badge":11,"icon":35,"path":36,"stem":37,"children":38,"page":32},"Fundamentals","i-lucide-layers","\u002Fdocs\u002Ffundamentals","docs\u002F2.fundamentals",[39,43,47,51,55,59],{"title":40,"path":41,"stem":42,"badge":11},"Fixture and Create","\u002Fdocs\u002Ffundamentals\u002Ffixture-and-create","docs\u002F2.fundamentals\u002F1.fixture-and-create",{"title":44,"path":45,"stem":46,"badge":11},"Build DSL","\u002Fdocs\u002Ffundamentals\u002Fbuild-dsl","docs\u002F2.fundamentals\u002F2.build-dsl",{"title":48,"path":49,"stem":50,"badge":11},"Customizations","\u002Fdocs\u002Ffundamentals\u002Fcustomizations","docs\u002F2.fundamentals\u002F3.customizations",{"title":52,"path":53,"stem":54,"badge":11},"Specimen graphs","\u002Fdocs\u002Ffundamentals\u002Fspecimen-graphs","docs\u002F2.fundamentals\u002F4.specimen-graphs",{"title":56,"path":57,"stem":58,"badge":11},"Behaviors","\u002Fdocs\u002Ffundamentals\u002Fbehaviors","docs\u002F2.fundamentals\u002F5.behaviors",{"title":60,"path":61,"stem":62,"badge":11},"Customizations catalog","\u002Fdocs\u002Ffundamentals\u002Fcustomizations-catalog","docs\u002F2.fundamentals\u002F6.customizations-catalog",{"title":64,"badge":11,"icon":65,"path":66,"stem":67,"children":68,"page":32},"How-to guides","i-lucide-book-open","\u002Fdocs\u002Fhow-to","docs\u002F3.how-to",[69,73,77,81],{"title":70,"path":71,"stem":72,"badge":11},"Collections","\u002Fdocs\u002Fhow-to\u002Fcollections","docs\u002F3.how-to\u002F1.collections",{"title":74,"path":75,"stem":76,"badge":11},"Circular references","\u002Fdocs\u002Fhow-to\u002Fcircular-refs","docs\u002F3.how-to\u002F2.circular-refs",{"title":78,"path":79,"stem":80,"badge":11},"Register, Freeze, and Inject","\u002Fdocs\u002Fhow-to\u002Fregister-freeze-inject","docs\u002F3.how-to\u002F3.register-freeze-inject",{"title":82,"path":83,"stem":84,"badge":11},"Data annotations","\u002Fdocs\u002Fhow-to\u002Fdata-annotations","docs\u002F3.how-to\u002F4.data-annotations",{"title":86,"badge":11,"icon":87,"path":88,"stem":89,"children":90,"page":32},"Extensions","i-lucide-puzzle","\u002Fdocs\u002Fextensions","docs\u002F4.extensions",[91,95],{"title":92,"path":93,"stem":94,"badge":11},"Idioms","\u002Fdocs\u002Fextensions\u002Fidioms","docs\u002F4.extensions\u002F1.idioms",{"title":96,"path":97,"stem":98,"badge":11},"Seed extensions","\u002Fdocs\u002Fextensions\u002Fseed-extensions","docs\u002F4.extensions\u002F2.seed-extensions",{"title":100,"badge":11,"icon":101,"path":102,"stem":103,"children":104,"page":32},"Integrations","i-lucide-plug","\u002Fdocs\u002Fintegrations","docs\u002F5.integrations",[105,109,113,117,121,125,129],{"title":106,"path":107,"stem":108,"badge":11},"Overview","\u002Fdocs\u002Fintegrations\u002Foverview","docs\u002F5.integrations\u002F00.overview",{"title":110,"path":111,"stem":112,"badge":11},"xUnit.net 3","\u002Fdocs\u002Fintegrations\u002Fxunit3","docs\u002F5.integrations\u002F01.xunit3",{"title":114,"path":115,"stem":116,"badge":11},"AutoMoq","\u002Fdocs\u002Fintegrations\u002Fautomoq","docs\u002F5.integrations\u002F02.automoq",{"title":118,"path":119,"stem":120,"badge":11},"NUnit 4","\u002Fdocs\u002Fintegrations\u002Fnunit4","docs\u002F5.integrations\u002F04.nunit4",{"title":122,"path":123,"stem":124,"badge":11},"AutoNSubstitute","\u002Fdocs\u002Fintegrations\u002Fautonsubstitute","docs\u002F5.integrations\u002F06.autonsubstitute",{"title":126,"path":127,"stem":128,"badge":11},"AutoFakeItEasy","\u002Fdocs\u002Fintegrations\u002Fautofakeiteasy","docs\u002F5.integrations\u002F09.autofakeiteasy",{"title":130,"path":131,"stem":132,"badge":133},"TUnit","\u002Fdocs\u002Fintegrations\u002Ftunit","docs\u002F5.integrations\u002F10.tunit",{"label":134,"color":135,"variant":136},"Preview","warning","subtle",{"title":138,"badge":11,"icon":139,"path":140,"stem":141,"children":142,"page":32},"Advanced","i-lucide-cog","\u002Fdocs\u002Fadvanced","docs\u002F6.advanced",[143,146,150],{"title":106,"path":144,"stem":145,"badge":11},"\u002Fdocs\u002Fadvanced\u002Foverview","docs\u002F6.advanced\u002F0.overview",{"title":147,"path":148,"stem":149,"badge":11},"Specimen pipeline","\u002Fdocs\u002Fadvanced\u002Fspecimen-pipeline","docs\u002F6.advanced\u002F1.specimen-pipeline",{"title":151,"path":152,"stem":153,"badge":11},"Specimen builders and specifications","\u002Fdocs\u002Fadvanced\u002Fspecimen-builders-and-specifications","docs\u002F6.advanced\u002F2.specimen-builders-and-specifications",{"title":155,"badge":11,"icon":156,"path":157,"stem":158,"children":159,"page":32},"Reference","i-lucide-library","\u002Fdocs\u002Freference","docs\u002F7.reference",[160,164,168,172,176,180,184],{"title":161,"path":162,"stem":163,"badge":11},"NuGet packages","\u002Fdocs\u002Freference\u002Fpackages","docs\u002F7.reference\u002F1.packages",{"title":165,"path":166,"stem":167,"badge":11},"API reference","\u002Fdocs\u002Freference\u002Fapi-reference","docs\u002F7.reference\u002F2.api-reference",{"title":169,"path":170,"stem":171,"badge":11},"Cheat sheet","\u002Fdocs\u002Freference\u002Fcheat-sheet","docs\u002F7.reference\u002F3.cheat-sheet",{"title":173,"path":174,"stem":175,"badge":11},"FAQ","\u002Fdocs\u002Freference\u002Ffaq","docs\u002F7.reference\u002F4.faq",{"title":177,"path":178,"stem":179,"badge":11},"Compatibility","\u002Fdocs\u002Freference\u002Fcompatibility","docs\u002F7.reference\u002F5.compatibility",{"title":181,"path":182,"stem":183,"badge":11},"v4 to v5 migration","\u002Fdocs\u002Freference\u002Fv4-to-v5-migration","docs\u002F7.reference\u002F6.v4-to-v5-migration",{"title":185,"path":186,"stem":187,"badge":11},"Previous versions","\u002Fdocs\u002Freference\u002Fprevious-versions","docs\u002F7.reference\u002F7.previous-versions",{"defaultPath":189,"packages":190},"\u002Fapi\u002Fautofixture\u002F5-0-0-rc-1",[191,204,210,215,221,227,232,238,243,248,253,258,264,271,276,281],{"id":192,"name":193,"nugetId":193,"primary":194,"versions":195,"defaultVersion":197,"defaultVersionSegment":198},"autofixture","AutoFixture",true,[196,200],{"version":197,"versionSegment":198,"line":199,"isLatest":194},"5.0.0-rc.1","5-0-0-rc-1","v5",{"version":201,"versionSegment":202,"line":203,"isLatest":32},"4.18.1","4-18-1","v4",{"id":205,"name":206,"nugetId":206,"primary":32,"versions":207,"defaultVersion":197,"defaultVersionSegment":198},"autofakeiteasy","AutoFixture.AutoFakeItEasy",[208,209],{"version":197,"versionSegment":198,"line":199,"isLatest":194},{"version":201,"versionSegment":202,"line":203,"isLatest":32},{"id":211,"name":212,"nugetId":212,"primary":32,"versions":213,"defaultVersion":201,"defaultVersionSegment":202},"autofoq","AutoFixture.AutoFoq",[214],{"version":201,"versionSegment":202,"line":203,"isLatest":194},{"id":216,"name":217,"nugetId":217,"primary":32,"versions":218,"defaultVersion":197,"defaultVersionSegment":198},"automoq","AutoFixture.AutoMoq",[219,220],{"version":197,"versionSegment":198,"line":199,"isLatest":194},{"version":201,"versionSegment":202,"line":203,"isLatest":32},{"id":222,"name":223,"nugetId":223,"primary":32,"versions":224,"defaultVersion":197,"defaultVersionSegment":198},"autonsubstitute","AutoFixture.AutoNSubstitute",[225,226],{"version":197,"versionSegment":198,"line":199,"isLatest":194},{"version":201,"versionSegment":202,"line":203,"isLatest":32},{"id":228,"name":229,"nugetId":229,"primary":32,"versions":230,"defaultVersion":201,"defaultVersionSegment":202},"autorhinomocks","AutoFixture.AutoRhinoMocks",[231],{"version":201,"versionSegment":202,"line":203,"isLatest":194},{"id":233,"name":234,"nugetId":234,"primary":32,"versions":235,"defaultVersion":197,"defaultVersionSegment":198},"idioms","AutoFixture.Idioms",[236,237],{"version":197,"versionSegment":198,"line":199,"isLatest":194},{"version":201,"versionSegment":202,"line":203,"isLatest":32},{"id":239,"name":240,"nugetId":240,"primary":32,"versions":241,"defaultVersion":201,"defaultVersionSegment":202},"idioms-fscheck","AutoFixture.Idioms.FsCheck",[242],{"version":201,"versionSegment":202,"line":203,"isLatest":194},{"id":244,"name":245,"nugetId":245,"primary":32,"versions":246,"defaultVersion":201,"defaultVersionSegment":202},"nunit2","AutoFixture.NUnit2",[247],{"version":201,"versionSegment":202,"line":203,"isLatest":194},{"id":249,"name":250,"nugetId":250,"primary":32,"versions":251,"defaultVersion":201,"defaultVersionSegment":202},"nunit3","AutoFixture.NUnit3",[252],{"version":201,"versionSegment":202,"line":203,"isLatest":194},{"id":254,"name":255,"nugetId":255,"primary":32,"versions":256,"defaultVersion":197,"defaultVersionSegment":198},"nunit4","AutoFixture.NUnit4",[257],{"version":197,"versionSegment":198,"line":199,"isLatest":194},{"id":259,"name":260,"nugetId":260,"primary":32,"versions":261,"defaultVersion":197,"defaultVersionSegment":198},"seedextensions","AutoFixture.SeedExtensions",[262,263],{"version":197,"versionSegment":198,"line":199,"isLatest":194},{"version":201,"versionSegment":202,"line":203,"isLatest":32},{"id":265,"name":266,"nugetId":266,"primary":32,"versions":267,"defaultVersion":269,"defaultVersionSegment":270},"tunit","AutoFixture.TUnit",[268],{"version":269,"versionSegment":270,"line":203,"isLatest":194},"0.1.0-preview0001","0-1-0-preview0001",{"id":272,"name":273,"nugetId":273,"primary":32,"versions":274,"defaultVersion":201,"defaultVersionSegment":202},"xunit","AutoFixture.xUnit",[275],{"version":201,"versionSegment":202,"line":203,"isLatest":194},{"id":277,"name":278,"nugetId":278,"primary":32,"versions":279,"defaultVersion":201,"defaultVersionSegment":202},"xunit2","AutoFixture.xUnit2",[280],{"version":201,"versionSegment":202,"line":203,"isLatest":194},{"id":282,"name":283,"nugetId":283,"primary":32,"versions":284,"defaultVersion":197,"defaultVersionSegment":198},"xunit3","AutoFixture.Xunit3",[285],{"version":197,"versionSegment":198,"line":199,"isLatest":194},[],{"id":288,"title":92,"badge":11,"body":289,"description":1917,"extension":1918,"meta":1919,"navigation":194,"path":93,"seo":1920,"stem":94,"updated":11,"__hash__":1921},"docs\u002Fdocs\u002F4.extensions\u002F1.idioms.md",{"type":290,"value":291,"toc":1903},"minimark",[292,300,305,318,322,368,372,375,379,388,391,545,548,641,644,700,725,729,738,862,866,875,999,1002,1006,1023,1116,1120,1138,1141,1257,1263,1267,1286,1289,1650,1653,1744,1752,1756,1816,1826,1830,1845,1849,1899],[293,294,295,296,299],"p",{},"The ",[297,298,234],"strong",{}," package provides assertions that use AutoFixture to exercise constructors, methods, and properties — so you do not write the same boilerplate tests by hand.",[301,302,304],"h2",{"id":303},"prerequisites","Prerequisites",[306,307,308,312],"ul",{},[309,310,311],"li",{},".NET 8+ test project",[309,313,314,317],{},[315,316,193],"a",{"href":22}," 5.0.0-rc.1",[301,319,321],{"id":320},"install","Install",[323,324,329],"pre",{"className":325,"code":326,"language":327,"meta":328,"style":328},"language-xml shiki shiki-themes light-plus light-plus dark-plus","\u003CPackageReference Include=\"AutoFixture.Idioms\" Version=\"5.0.0-rc.1\" \u002F>\n","xml","",[330,331,332],"code",{"__ignoreMap":328},[333,334,337,341,345,349,353,357,360,362,365],"span",{"class":335,"line":336},"line",1,[333,338,340],{"class":339},"s9Xrk","\u003C",[333,342,344],{"class":343},"swrg_","PackageReference",[333,346,348],{"class":347},"ssBXb"," Include",[333,350,352],{"class":351},"s_Yst","=",[333,354,356],{"class":355},"swG-L","\"AutoFixture.Idioms\"",[333,358,359],{"class":347}," Version",[333,361,352],{"class":351},[333,363,364],{"class":355},"\"5.0.0-rc.1\"",[333,366,367],{"class":339}," \u002F>\n",[301,369,371],{"id":370},"example-scenario","Example scenario",[293,373,374],{},"You are hardening a public API. You want to verify guard clauses, constructor initialization, writable properties, and equality comparers without one repetitive test per member.",[301,376,378],{"id":377},"guard-clauses","Guard clauses",[293,380,381,387],{},[315,382,384],{"href":383},"\u002Fapi\u002Fidioms\u002F5-0-0-rc-1\u002Fautofixture.idioms.guardclauseassertion",[330,385,386],{},"GuardClauseAssertion"," invokes members with null and invalid inputs and checks that the right exceptions are thrown.",[293,389,390],{},"Constructor:",[323,392,396],{"className":393,"code":394,"language":395,"meta":328,"style":328},"language-csharp shiki shiki-themes light-plus light-plus dark-plus","var fixture = new Fixture();\nvar assertion = new GuardClauseAssertion(fixture);\nvar constructor = typeof(GuardedOrderProcessor).GetConstructors().Single();\n\nvar exception = Record.Exception(() => assertion.Verify(constructor));\n\nAssert.Null(exception);\n","csharp",[330,397,398,421,445,478,484,522,527],{"__ignoreMap":328},[333,399,400,404,408,411,414,418],{"class":335,"line":336},[333,401,403],{"class":402},"stxUP","var",[333,405,407],{"class":406},"sswaR"," fixture",[333,409,410],{"class":351}," = ",[333,412,413],{"class":402},"new",[333,415,417],{"class":416},"sopvc"," Fixture",[333,419,420],{"class":351},"();\n",[333,422,424,426,429,431,433,436,439,442],{"class":335,"line":423},2,[333,425,403],{"class":402},[333,427,428],{"class":406}," assertion",[333,430,410],{"class":351},[333,432,413],{"class":402},[333,434,435],{"class":416}," GuardClauseAssertion",[333,437,438],{"class":351},"(",[333,440,441],{"class":406},"fixture",[333,443,444],{"class":351},");\n",[333,446,448,450,453,455,458,460,463,466,470,473,476],{"class":335,"line":447},3,[333,449,403],{"class":402},[333,451,452],{"class":406}," constructor",[333,454,410],{"class":351},[333,456,457],{"class":402},"typeof",[333,459,438],{"class":351},[333,461,462],{"class":416},"GuardedOrderProcessor",[333,464,465],{"class":351},").",[333,467,469],{"class":468},"swoLU","GetConstructors",[333,471,472],{"class":351},"().",[333,474,475],{"class":468},"Single",[333,477,420],{"class":351},[333,479,481],{"class":335,"line":480},4,[333,482,483],{"emptyLinePlaceholder":194},"\n",[333,485,487,489,492,494,497,500,503,506,509,511,514,516,519],{"class":335,"line":486},5,[333,488,403],{"class":402},[333,490,491],{"class":406}," exception",[333,493,410],{"class":351},[333,495,496],{"class":406},"Record",[333,498,499],{"class":351},".",[333,501,502],{"class":468},"Exception",[333,504,505],{"class":351},"(() => ",[333,507,508],{"class":406},"assertion",[333,510,499],{"class":351},[333,512,513],{"class":468},"Verify",[333,515,438],{"class":351},[333,517,518],{"class":406},"constructor",[333,520,521],{"class":351},"));\n",[333,523,525],{"class":335,"line":524},6,[333,526,483],{"emptyLinePlaceholder":194},[333,528,530,533,535,538,540,543],{"class":335,"line":529},7,[333,531,532],{"class":406},"Assert",[333,534,499],{"class":351},[333,536,537],{"class":468},"Null",[333,539,438],{"class":351},[333,541,542],{"class":406},"exception",[333,544,444],{"class":351},[293,546,547],{},"Method:",[323,549,551],{"className":393,"code":550,"language":395,"meta":328,"style":328},"var method = typeof(GuardedOrderProcessor).GetMethod(nameof(GuardedOrderProcessor.Process));\n\nvar exception = Record.Exception(() => assertion.Verify(method!));\n\nAssert.Null(exception);\n",[330,552,553,589,593,623,627],{"__ignoreMap":328},[333,554,555,557,560,562,564,566,568,570,573,575,578,580,582,584,587],{"class":335,"line":336},[333,556,403],{"class":402},[333,558,559],{"class":406}," method",[333,561,410],{"class":351},[333,563,457],{"class":402},[333,565,438],{"class":351},[333,567,462],{"class":416},[333,569,465],{"class":351},[333,571,572],{"class":468},"GetMethod",[333,574,438],{"class":351},[333,576,577],{"class":402},"nameof",[333,579,438],{"class":351},[333,581,462],{"class":406},[333,583,499],{"class":351},[333,585,586],{"class":406},"Process",[333,588,521],{"class":351},[333,590,591],{"class":335,"line":423},[333,592,483],{"emptyLinePlaceholder":194},[333,594,595,597,599,601,603,605,607,609,611,613,615,617,620],{"class":335,"line":447},[333,596,403],{"class":402},[333,598,491],{"class":406},[333,600,410],{"class":351},[333,602,496],{"class":406},[333,604,499],{"class":351},[333,606,502],{"class":468},[333,608,505],{"class":351},[333,610,508],{"class":406},[333,612,499],{"class":351},[333,614,513],{"class":468},[333,616,438],{"class":351},[333,618,619],{"class":406},"method",[333,621,622],{"class":351},"!));\n",[333,624,625],{"class":335,"line":480},[333,626,483],{"emptyLinePlaceholder":194},[333,628,629,631,633,635,637,639],{"class":335,"line":486},[333,630,532],{"class":406},[333,632,499],{"class":351},[333,634,537],{"class":468},[333,636,438],{"class":351},[333,638,542],{"class":406},[333,640,444],{"class":351},[293,642,643],{},"Sweep a whole type:",[323,645,647],{"className":393,"code":646,"language":395,"meta":328,"style":328},"var exception = Record.Exception(() => assertion.Verify(typeof(GuardedOrderProcessor)));\n\nAssert.Null(exception);\n",[330,648,649,682,686],{"__ignoreMap":328},[333,650,651,653,655,657,659,661,663,665,667,669,671,673,675,677,679],{"class":335,"line":336},[333,652,403],{"class":402},[333,654,491],{"class":406},[333,656,410],{"class":351},[333,658,496],{"class":406},[333,660,499],{"class":351},[333,662,502],{"class":468},[333,664,505],{"class":351},[333,666,508],{"class":406},[333,668,499],{"class":351},[333,670,513],{"class":468},[333,672,438],{"class":351},[333,674,457],{"class":402},[333,676,438],{"class":351},[333,678,462],{"class":416},[333,680,681],{"class":351},")));\n",[333,683,684],{"class":335,"line":423},[333,685,483],{"emptyLinePlaceholder":194},[333,687,688,690,692,694,696,698],{"class":335,"line":447},[333,689,532],{"class":406},[333,691,499],{"class":351},[333,693,537],{"class":468},[333,695,438],{"class":351},[333,697,542],{"class":406},[333,699,444],{"class":351},[293,701,702,703,706,707,710,711,714,715,714,718,721,722,724],{},"Pass an ",[330,704,705],{},"Assembly",", ",[330,708,709],{},"Type",", or individual ",[330,712,713],{},"ConstructorInfo"," \u002F ",[330,716,717],{},"MethodInfo",[330,719,720],{},"PropertyInfo"," to ",[330,723,513],{}," depending on how much of the surface you want to check.",[301,726,728],{"id":727},"constructor-initialized-members","Constructor-initialized members",[293,730,731,737],{},[315,732,734],{"href":733},"\u002Fapi\u002Fidioms\u002F5-0-0-rc-1\u002Fautofixture.idioms.constructorinitializedmemberassertion",[330,735,736],{},"ConstructorInitializedMemberAssertion"," checks that a read-only property or field holds the value passed to the matching constructor parameter:",[323,739,741],{"className":393,"code":740,"language":395,"meta":328,"style":328},"var fixture = new Fixture();\nvar assertion = new ConstructorInitializedMemberAssertion(fixture);\nvar store = typeof(GuardedOrderProcessor).GetProperty(nameof(GuardedOrderProcessor.Store));\n\nvar exception = Record.Exception(() => assertion.Verify(store!));\n\nAssert.Null(exception);\n",[330,742,743,757,776,811,815,844,848],{"__ignoreMap":328},[333,744,745,747,749,751,753,755],{"class":335,"line":336},[333,746,403],{"class":402},[333,748,407],{"class":406},[333,750,410],{"class":351},[333,752,413],{"class":402},[333,754,417],{"class":416},[333,756,420],{"class":351},[333,758,759,761,763,765,767,770,772,774],{"class":335,"line":423},[333,760,403],{"class":402},[333,762,428],{"class":406},[333,764,410],{"class":351},[333,766,413],{"class":402},[333,768,769],{"class":416}," ConstructorInitializedMemberAssertion",[333,771,438],{"class":351},[333,773,441],{"class":406},[333,775,444],{"class":351},[333,777,778,780,783,785,787,789,791,793,796,798,800,802,804,806,809],{"class":335,"line":447},[333,779,403],{"class":402},[333,781,782],{"class":406}," store",[333,784,410],{"class":351},[333,786,457],{"class":402},[333,788,438],{"class":351},[333,790,462],{"class":416},[333,792,465],{"class":351},[333,794,795],{"class":468},"GetProperty",[333,797,438],{"class":351},[333,799,577],{"class":402},[333,801,438],{"class":351},[333,803,462],{"class":406},[333,805,499],{"class":351},[333,807,808],{"class":406},"Store",[333,810,521],{"class":351},[333,812,813],{"class":335,"line":480},[333,814,483],{"emptyLinePlaceholder":194},[333,816,817,819,821,823,825,827,829,831,833,835,837,839,842],{"class":335,"line":486},[333,818,403],{"class":402},[333,820,491],{"class":406},[333,822,410],{"class":351},[333,824,496],{"class":406},[333,826,499],{"class":351},[333,828,502],{"class":468},[333,830,505],{"class":351},[333,832,508],{"class":406},[333,834,499],{"class":351},[333,836,513],{"class":468},[333,838,438],{"class":351},[333,840,841],{"class":406},"store",[333,843,622],{"class":351},[333,845,846],{"class":335,"line":524},[333,847,483],{"emptyLinePlaceholder":194},[333,849,850,852,854,856,858,860],{"class":335,"line":529},[333,851,532],{"class":406},[333,853,499],{"class":351},[333,855,537],{"class":468},[333,857,438],{"class":351},[333,859,542],{"class":406},[333,861,444],{"class":351},[301,863,865],{"id":864},"writable-properties","Writable properties",[293,867,868,874],{},[315,869,871],{"href":870},"\u002Fapi\u002Fidioms\u002F5-0-0-rc-1\u002Fautofixture.idioms.writablepropertyassertion",[330,872,873],{},"WritablePropertyAssertion"," assigns a value through the setter and checks that the getter returns the same value:",[323,876,878],{"className":393,"code":877,"language":395,"meta":328,"style":328},"var fixture = new Fixture();\nvar assertion = new WritablePropertyAssertion(fixture);\nvar name = typeof(Person).GetProperty(nameof(Person.Name));\n\nvar exception = Record.Exception(() => assertion.Verify(name!));\n\nAssert.Null(exception);\n",[330,879,880,894,913,948,952,981,985],{"__ignoreMap":328},[333,881,882,884,886,888,890,892],{"class":335,"line":336},[333,883,403],{"class":402},[333,885,407],{"class":406},[333,887,410],{"class":351},[333,889,413],{"class":402},[333,891,417],{"class":416},[333,893,420],{"class":351},[333,895,896,898,900,902,904,907,909,911],{"class":335,"line":423},[333,897,403],{"class":402},[333,899,428],{"class":406},[333,901,410],{"class":351},[333,903,413],{"class":402},[333,905,906],{"class":416}," WritablePropertyAssertion",[333,908,438],{"class":351},[333,910,441],{"class":406},[333,912,444],{"class":351},[333,914,915,917,920,922,924,926,929,931,933,935,937,939,941,943,946],{"class":335,"line":447},[333,916,403],{"class":402},[333,918,919],{"class":406}," name",[333,921,410],{"class":351},[333,923,457],{"class":402},[333,925,438],{"class":351},[333,927,928],{"class":416},"Person",[333,930,465],{"class":351},[333,932,795],{"class":468},[333,934,438],{"class":351},[333,936,577],{"class":402},[333,938,438],{"class":351},[333,940,928],{"class":406},[333,942,499],{"class":351},[333,944,945],{"class":406},"Name",[333,947,521],{"class":351},[333,949,950],{"class":335,"line":480},[333,951,483],{"emptyLinePlaceholder":194},[333,953,954,956,958,960,962,964,966,968,970,972,974,976,979],{"class":335,"line":486},[333,955,403],{"class":402},[333,957,491],{"class":406},[333,959,410],{"class":351},[333,961,496],{"class":406},[333,963,499],{"class":351},[333,965,502],{"class":468},[333,967,505],{"class":351},[333,969,508],{"class":406},[333,971,499],{"class":351},[333,973,513],{"class":468},[333,975,438],{"class":351},[333,977,978],{"class":406},"name",[333,980,622],{"class":351},[333,982,983],{"class":335,"line":524},[333,984,483],{"emptyLinePlaceholder":194},[333,986,987,989,991,993,995,997],{"class":335,"line":529},[333,988,532],{"class":406},[333,990,499],{"class":351},[333,992,537],{"class":468},[333,994,438],{"class":351},[333,996,542],{"class":406},[333,998,444],{"class":351},[293,1000,1001],{},"Read-only properties are skipped automatically.",[301,1003,1005],{"id":1004},"equality-comparers","Equality comparers",[293,1007,1008,1014,1015,1018,1019,1022],{},[315,1009,1011],{"href":1010},"\u002Fapi\u002Fidioms\u002F5-0-0-rc-1\u002Fautofixture.idioms.equalitycomparerassertion",[330,1012,1013],{},"EqualityComparerAssertion"," exercises ",[330,1016,1017],{},"IEqualityComparer\u003CT>"," implementations for null handling, symmetry, transitivity, and consistent ",[330,1020,1021],{},"GetHashCode",":",[323,1024,1026],{"className":393,"code":1025,"language":395,"meta":328,"style":328},"var fixture = new Fixture();\nvar assertion = new EqualityComparerAssertion(fixture);\n\nvar exception = Record.Exception(() => assertion.Verify(typeof(ProductCodeComparer)));\n\nAssert.Null(exception);\n",[330,1027,1028,1042,1061,1065,1098,1102],{"__ignoreMap":328},[333,1029,1030,1032,1034,1036,1038,1040],{"class":335,"line":336},[333,1031,403],{"class":402},[333,1033,407],{"class":406},[333,1035,410],{"class":351},[333,1037,413],{"class":402},[333,1039,417],{"class":416},[333,1041,420],{"class":351},[333,1043,1044,1046,1048,1050,1052,1055,1057,1059],{"class":335,"line":423},[333,1045,403],{"class":402},[333,1047,428],{"class":406},[333,1049,410],{"class":351},[333,1051,413],{"class":402},[333,1053,1054],{"class":416}," EqualityComparerAssertion",[333,1056,438],{"class":351},[333,1058,441],{"class":406},[333,1060,444],{"class":351},[333,1062,1063],{"class":335,"line":447},[333,1064,483],{"emptyLinePlaceholder":194},[333,1066,1067,1069,1071,1073,1075,1077,1079,1081,1083,1085,1087,1089,1091,1093,1096],{"class":335,"line":480},[333,1068,403],{"class":402},[333,1070,491],{"class":406},[333,1072,410],{"class":351},[333,1074,496],{"class":406},[333,1076,499],{"class":351},[333,1078,502],{"class":468},[333,1080,505],{"class":351},[333,1082,508],{"class":406},[333,1084,499],{"class":351},[333,1086,513],{"class":468},[333,1088,438],{"class":351},[333,1090,457],{"class":402},[333,1092,438],{"class":351},[333,1094,1095],{"class":416},"ProductCodeComparer",[333,1097,681],{"class":351},[333,1099,1100],{"class":335,"line":486},[333,1101,483],{"emptyLinePlaceholder":194},[333,1103,1104,1106,1108,1110,1112,1114],{"class":335,"line":524},[333,1105,532],{"class":406},[333,1107,499],{"class":351},[333,1109,537],{"class":468},[333,1111,438],{"class":351},[333,1113,542],{"class":406},[333,1115,444],{"class":351},[301,1117,1119],{"id":1118},"composite-assertions","Composite assertions",[293,1121,1122,1128,1129,1132,1133,1137],{},[315,1123,1125],{"href":1124},"\u002Fapi\u002Fidioms\u002F5-0-0-rc-1\u002Fautofixture.idioms.compositeidiomaticassertion",[330,1126,1127],{},"CompositeIdiomaticAssertion"," runs several ",[330,1130,1131],{},"IIdiomaticAssertion"," instances against the same target. ",[315,1134,1135],{"href":1010},[330,1136,1013],{}," is itself a composite of the individual equality-comparer checks.",[293,1139,1140],{},"Combine built-in assertions for a type:",[323,1142,1144],{"className":393,"code":1143,"language":395,"meta":328,"style":328},"var fixture = new Fixture();\nvar assertion = new CompositeIdiomaticAssertion(\n    new GuardClauseAssertion(fixture),\n    new ConstructorInitializedMemberAssertion(fixture));\n\nvar exception = Record.Exception(() => assertion.Verify(typeof(GuardedOrderProcessor)));\n\nAssert.Null(exception);\n",[330,1145,1146,1160,1176,1190,1202,1206,1238,1242],{"__ignoreMap":328},[333,1147,1148,1150,1152,1154,1156,1158],{"class":335,"line":336},[333,1149,403],{"class":402},[333,1151,407],{"class":406},[333,1153,410],{"class":351},[333,1155,413],{"class":402},[333,1157,417],{"class":416},[333,1159,420],{"class":351},[333,1161,1162,1164,1166,1168,1170,1173],{"class":335,"line":423},[333,1163,403],{"class":402},[333,1165,428],{"class":406},[333,1167,410],{"class":351},[333,1169,413],{"class":402},[333,1171,1172],{"class":416}," CompositeIdiomaticAssertion",[333,1174,1175],{"class":351},"(\n",[333,1177,1178,1181,1183,1185,1187],{"class":335,"line":447},[333,1179,1180],{"class":402},"    new",[333,1182,435],{"class":416},[333,1184,438],{"class":351},[333,1186,441],{"class":406},[333,1188,1189],{"class":351},"),\n",[333,1191,1192,1194,1196,1198,1200],{"class":335,"line":480},[333,1193,1180],{"class":402},[333,1195,769],{"class":416},[333,1197,438],{"class":351},[333,1199,441],{"class":406},[333,1201,521],{"class":351},[333,1203,1204],{"class":335,"line":486},[333,1205,483],{"emptyLinePlaceholder":194},[333,1207,1208,1210,1212,1214,1216,1218,1220,1222,1224,1226,1228,1230,1232,1234,1236],{"class":335,"line":524},[333,1209,403],{"class":402},[333,1211,491],{"class":406},[333,1213,410],{"class":351},[333,1215,496],{"class":406},[333,1217,499],{"class":351},[333,1219,502],{"class":468},[333,1221,505],{"class":351},[333,1223,508],{"class":406},[333,1225,499],{"class":351},[333,1227,513],{"class":468},[333,1229,438],{"class":351},[333,1231,457],{"class":402},[333,1233,438],{"class":351},[333,1235,462],{"class":416},[333,1237,681],{"class":351},[333,1239,1240],{"class":335,"line":529},[333,1241,483],{"emptyLinePlaceholder":194},[333,1243,1245,1247,1249,1251,1253,1255],{"class":335,"line":1244},8,[333,1246,532],{"class":406},[333,1248,499],{"class":351},[333,1250,537],{"class":468},[333,1252,438],{"class":351},[333,1254,542],{"class":406},[333,1256,444],{"class":351},[293,1258,1259,1260,1262],{},"Each child assertion receives the same ",[330,1261,513],{}," call — constructor, method, property, type, or assembly.",[301,1264,1266],{"id":1265},"custom-assertions","Custom assertions",[293,1268,1269,1270,1275,1276,1282,1283,1285],{},"Implement ",[315,1271,1273],{"href":1272},"\u002Fapi\u002Fidioms\u002F5-0-0-rc-1\u002Fautofixture.idioms.iidiomaticassertion",[330,1274,1131],{}," directly, or subclass ",[315,1277,1279],{"href":1278},"\u002Fapi\u002Fidioms\u002F5-0-0-rc-1\u002Fautofixture.idioms.idiomaticassertion",[330,1280,1281],{},"IdiomaticAssertion"," and override the ",[330,1284,513],{}," overloads you need. The base class walks assemblies, types, and members for you.",[293,1287,1288],{},"This example encodes a team rule — exactly one public constructor, and AutoFixture must be able to construct the type:",[323,1290,1292],{"className":393,"code":1291,"language":395,"meta":328,"style":328},"using System.Reflection;\nusing AutoFixture.Kernel;\nusing AutoFixture.Idioms;\n\npublic sealed class SinglePublicConstructorAssertion(ISpecimenBuilder builder) : IdiomaticAssertion\n{\n    public ISpecimenBuilder Builder { get; } = builder ?? throw new ArgumentNullException(nameof(builder));\n\n    public override void Verify(Type type)\n    {\n        if (type is null)\n            throw new ArgumentNullException(nameof(type));\n\n        var constructors = type.GetConstructors();\n        if (constructors.Length != 1)\n        {\n            throw new InvalidOperationException(\n                $\"Type '{type.FullName}' must expose exactly one public constructor, but found {constructors.Length}.\");\n        }\n\n        _ = new SpecimenContext(Builder).Resolve(type);\n    }\n}\n",[330,1293,1294,1311,1325,1337,1341,1369,1374,1419,1423,1447,1453,1473,1493,1498,1517,1541,1547,1559,1598,1604,1609,1638,1644],{"__ignoreMap":328},[333,1295,1296,1300,1303,1305,1308],{"class":335,"line":336},[333,1297,1299],{"class":1298},"smUd-","using",[333,1301,1302],{"class":416}," System",[333,1304,499],{"class":351},[333,1306,1307],{"class":416},"Reflection",[333,1309,1310],{"class":351},";\n",[333,1312,1313,1315,1318,1320,1323],{"class":335,"line":423},[333,1314,1299],{"class":1298},[333,1316,1317],{"class":416}," AutoFixture",[333,1319,499],{"class":351},[333,1321,1322],{"class":416},"Kernel",[333,1324,1310],{"class":351},[333,1326,1327,1329,1331,1333,1335],{"class":335,"line":447},[333,1328,1299],{"class":1298},[333,1330,1317],{"class":416},[333,1332,499],{"class":351},[333,1334,92],{"class":416},[333,1336,1310],{"class":351},[333,1338,1339],{"class":335,"line":480},[333,1340,483],{"emptyLinePlaceholder":194},[333,1342,1343,1346,1349,1352,1355,1357,1360,1363,1366],{"class":335,"line":486},[333,1344,1345],{"class":402},"public",[333,1347,1348],{"class":402}," sealed",[333,1350,1351],{"class":402}," class",[333,1353,1354],{"class":416}," SinglePublicConstructorAssertion",[333,1356,438],{"class":351},[333,1358,1359],{"class":416},"ISpecimenBuilder",[333,1361,1362],{"class":406}," builder",[333,1364,1365],{"class":351},") : ",[333,1367,1368],{"class":416},"IdiomaticAssertion\n",[333,1370,1371],{"class":335,"line":524},[333,1372,1373],{"class":351},"{\n",[333,1375,1376,1379,1382,1385,1388,1391,1394,1397,1400,1403,1406,1409,1411,1413,1415,1417],{"class":335,"line":529},[333,1377,1378],{"class":402},"    public",[333,1380,1381],{"class":416}," ISpecimenBuilder",[333,1383,1384],{"class":406}," Builder",[333,1386,1387],{"class":351}," { ",[333,1389,1390],{"class":402},"get",[333,1392,1393],{"class":351},"; } = ",[333,1395,1396],{"class":406},"builder",[333,1398,1399],{"class":351}," ?? ",[333,1401,1402],{"class":1298},"throw",[333,1404,1405],{"class":402}," new",[333,1407,1408],{"class":416}," ArgumentNullException",[333,1410,438],{"class":351},[333,1412,577],{"class":402},[333,1414,438],{"class":351},[333,1416,1396],{"class":406},[333,1418,521],{"class":351},[333,1420,1421],{"class":335,"line":1244},[333,1422,483],{"emptyLinePlaceholder":194},[333,1424,1426,1428,1431,1434,1437,1439,1441,1444],{"class":335,"line":1425},9,[333,1427,1378],{"class":402},[333,1429,1430],{"class":402}," override",[333,1432,1433],{"class":402}," void",[333,1435,1436],{"class":468}," Verify",[333,1438,438],{"class":351},[333,1440,709],{"class":416},[333,1442,1443],{"class":406}," type",[333,1445,1446],{"class":351},")\n",[333,1448,1450],{"class":335,"line":1449},10,[333,1451,1452],{"class":351},"    {\n",[333,1454,1456,1459,1462,1465,1468,1471],{"class":335,"line":1455},11,[333,1457,1458],{"class":1298},"        if",[333,1460,1461],{"class":351}," (",[333,1463,1464],{"class":406},"type",[333,1466,1467],{"class":402}," is",[333,1469,1470],{"class":402}," null",[333,1472,1446],{"class":351},[333,1474,1476,1479,1481,1483,1485,1487,1489,1491],{"class":335,"line":1475},12,[333,1477,1478],{"class":1298},"            throw",[333,1480,1405],{"class":402},[333,1482,1408],{"class":416},[333,1484,438],{"class":351},[333,1486,577],{"class":402},[333,1488,438],{"class":351},[333,1490,1464],{"class":406},[333,1492,521],{"class":351},[333,1494,1496],{"class":335,"line":1495},13,[333,1497,483],{"emptyLinePlaceholder":194},[333,1499,1501,1504,1507,1509,1511,1513,1515],{"class":335,"line":1500},14,[333,1502,1503],{"class":402},"        var",[333,1505,1506],{"class":406}," constructors",[333,1508,410],{"class":351},[333,1510,1464],{"class":406},[333,1512,499],{"class":351},[333,1514,469],{"class":468},[333,1516,420],{"class":351},[333,1518,1520,1522,1524,1527,1529,1532,1535,1539],{"class":335,"line":1519},15,[333,1521,1458],{"class":1298},[333,1523,1461],{"class":351},[333,1525,1526],{"class":406},"constructors",[333,1528,499],{"class":351},[333,1530,1531],{"class":406},"Length",[333,1533,1534],{"class":351}," != ",[333,1536,1538],{"class":1537},"s-S-M","1",[333,1540,1446],{"class":351},[333,1542,1544],{"class":335,"line":1543},16,[333,1545,1546],{"class":351},"        {\n",[333,1548,1550,1552,1554,1557],{"class":335,"line":1549},17,[333,1551,1478],{"class":1298},[333,1553,1405],{"class":402},[333,1555,1556],{"class":416}," InvalidOperationException",[333,1558,1175],{"class":351},[333,1560,1562,1566,1570,1572,1574,1577,1580,1583,1585,1587,1589,1591,1593,1596],{"class":335,"line":1561},18,[333,1563,1565],{"class":1564},"sFD8J","                $\"Type '",[333,1567,1569],{"class":1568},"sw10w","{",[333,1571,1464],{"class":406},[333,1573,499],{"class":1568},[333,1575,1576],{"class":406},"FullName",[333,1578,1579],{"class":1568},"}",[333,1581,1582],{"class":1564},"' must expose exactly one public constructor, but found ",[333,1584,1569],{"class":1568},[333,1586,1526],{"class":406},[333,1588,499],{"class":1568},[333,1590,1531],{"class":406},[333,1592,1579],{"class":1568},[333,1594,1595],{"class":1564},".\"",[333,1597,444],{"class":351},[333,1599,1601],{"class":335,"line":1600},19,[333,1602,1603],{"class":351},"        }\n",[333,1605,1607],{"class":335,"line":1606},20,[333,1608,483],{"emptyLinePlaceholder":194},[333,1610,1612,1615,1617,1619,1622,1624,1627,1629,1632,1634,1636],{"class":335,"line":1611},21,[333,1613,1614],{"class":406},"        _",[333,1616,410],{"class":351},[333,1618,413],{"class":402},[333,1620,1621],{"class":416}," SpecimenContext",[333,1623,438],{"class":351},[333,1625,1626],{"class":406},"Builder",[333,1628,465],{"class":351},[333,1630,1631],{"class":468},"Resolve",[333,1633,438],{"class":351},[333,1635,1464],{"class":406},[333,1637,444],{"class":351},[333,1639,1641],{"class":335,"line":1640},22,[333,1642,1643],{"class":351},"    }\n",[333,1645,1647],{"class":335,"line":1646},23,[333,1648,1649],{"class":351},"}\n",[293,1651,1652],{},"Use it like any built-in assertion:",[323,1654,1656],{"className":393,"code":1655,"language":395,"meta":328,"style":328},"var fixture = new Fixture();\nvar assertion = new SinglePublicConstructorAssertion(fixture);\n\nvar exception = Record.Exception(() => assertion.Verify(typeof(GuardedOrderProcessor)));\n\nAssert.Null(exception);\n",[330,1657,1658,1672,1690,1694,1726,1730],{"__ignoreMap":328},[333,1659,1660,1662,1664,1666,1668,1670],{"class":335,"line":336},[333,1661,403],{"class":402},[333,1663,407],{"class":406},[333,1665,410],{"class":351},[333,1667,413],{"class":402},[333,1669,417],{"class":416},[333,1671,420],{"class":351},[333,1673,1674,1676,1678,1680,1682,1684,1686,1688],{"class":335,"line":423},[333,1675,403],{"class":402},[333,1677,428],{"class":406},[333,1679,410],{"class":351},[333,1681,413],{"class":402},[333,1683,1354],{"class":416},[333,1685,438],{"class":351},[333,1687,441],{"class":406},[333,1689,444],{"class":351},[333,1691,1692],{"class":335,"line":447},[333,1693,483],{"emptyLinePlaceholder":194},[333,1695,1696,1698,1700,1702,1704,1706,1708,1710,1712,1714,1716,1718,1720,1722,1724],{"class":335,"line":480},[333,1697,403],{"class":402},[333,1699,491],{"class":406},[333,1701,410],{"class":351},[333,1703,496],{"class":406},[333,1705,499],{"class":351},[333,1707,502],{"class":468},[333,1709,505],{"class":351},[333,1711,508],{"class":406},[333,1713,499],{"class":351},[333,1715,513],{"class":468},[333,1717,438],{"class":351},[333,1719,457],{"class":402},[333,1721,438],{"class":351},[333,1723,462],{"class":416},[333,1725,681],{"class":351},[333,1727,1728],{"class":335,"line":486},[333,1729,483],{"emptyLinePlaceholder":194},[333,1731,1732,1734,1736,1738,1740,1742],{"class":335,"line":524},[333,1733,532],{"class":406},[333,1735,499],{"class":351},[333,1737,537],{"class":468},[333,1739,438],{"class":351},[333,1741,542],{"class":406},[333,1743,444],{"class":351},[293,1745,1746,1747,1751],{},"Add your custom assertion to a ",[315,1748,1749],{"href":1124},[330,1750,1127],{}," when you want it in a standard API sweep.",[301,1753,1755],{"id":1754},"how-it-works","How it works",[306,1757,1758,1765,1772,1779,1789,1796,1807],{},[309,1759,1760,1764],{},[297,1761,1762],{},[330,1763,386],{}," — null\u002Finvalid inputs on constructors and methods must throw",[309,1766,1767,1771],{},[297,1768,1769],{},[330,1770,736],{}," — constructor parameters flow into matching members",[309,1773,1774,1778],{},[297,1775,1776],{},[330,1777,873],{}," — setter\u002Fgetter round-trip for writable properties",[309,1780,1781,1785,1786,1788],{},[297,1782,1783],{},[330,1784,1013],{}," — composite checks for custom ",[330,1787,1017],{}," types",[309,1790,1791,1795],{},[297,1792,1793],{},[330,1794,1127],{}," — runs multiple assertions against the same reflection target",[309,1797,1798,1803,1804,1806],{},[297,1799,1800,1801],{},"Custom ",[330,1802,1281],{}," — override selected ",[330,1805,513],{}," overloads for team-specific rules",[309,1808,1809,1815],{},[297,1810,1811,1814],{},[330,1812,1813],{},"Verify(...)"," overloads"," — target a single member, a type, or an entire assembly",[293,1817,1818,1819,1821,1822,1825],{},"All assertions take an ",[330,1820,1359],{}," (usually ",[330,1823,1824],{},"new Fixture()",") to create the arguments and owners they need.",[301,1827,1829],{"id":1828},"next-steps","Next steps",[306,1831,1832,1837,1841],{},[309,1833,1834],{},[315,1835,1836],{"href":144},"Advanced overview",[309,1838,1839],{},[315,1840,48],{"href":49},[309,1842,1843],{},[315,1844,96],{"href":97},[301,1846,1848],{"id":1847},"api","API",[306,1850,1851,1857,1863,1869,1875,1881,1887,1893],{},[309,1852,1853],{},[315,1854,1856],{"href":1855},"\u002Fapi\u002Fidioms\u002F5-0-0-rc-1","AutoFixture.Idioms package",[309,1858,1859],{},[315,1860,1861],{"href":383},[330,1862,386],{},[309,1864,1865],{},[315,1866,1867],{"href":733},[330,1868,736],{},[309,1870,1871],{},[315,1872,1873],{"href":870},[330,1874,873],{},[309,1876,1877],{},[315,1878,1879],{"href":1010},[330,1880,1013],{},[309,1882,1883],{},[315,1884,1885],{"href":1124},[330,1886,1127],{},[309,1888,1889],{},[315,1890,1891],{"href":1272},[330,1892,1131],{},[309,1894,1895],{},[315,1896,1897],{"href":1278},[330,1898,1281],{},[1900,1901,1902],"style",{},"html pre.shiki code .s9Xrk, html code.shiki .s9Xrk{--shiki-light:#800000;--shiki-default:#800000;--shiki-dark:#808080}html pre.shiki code .swrg_, html code.shiki .swrg_{--shiki-light:#800000;--shiki-default:#800000;--shiki-dark:#569CD6}html pre.shiki code .ssBXb, html code.shiki .ssBXb{--shiki-light:#E50000;--shiki-default:#E50000;--shiki-dark:#9CDCFE}html pre.shiki code .s_Yst, html code.shiki .s_Yst{--shiki-light:#000000;--shiki-default:#000000;--shiki-dark:#D4D4D4}html pre.shiki code .swG-L, html code.shiki .swG-L{--shiki-light:#0000FF;--shiki-default:#0000FF;--shiki-dark:#CE9178}html .light .shiki span {color: var(--shiki-light);background: var(--shiki-light-bg);font-style: var(--shiki-light-font-style);font-weight: var(--shiki-light-font-weight);text-decoration: var(--shiki-light-text-decoration);}html.light .shiki span {color: var(--shiki-light);background: var(--shiki-light-bg);font-style: var(--shiki-light-font-style);font-weight: var(--shiki-light-font-weight);text-decoration: var(--shiki-light-text-decoration);}html .default .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .shiki span {color: var(--shiki-default);background: var(--shiki-default-bg);font-style: var(--shiki-default-font-style);font-weight: var(--shiki-default-font-weight);text-decoration: var(--shiki-default-text-decoration);}html .dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html.dark .shiki span {color: var(--shiki-dark);background: var(--shiki-dark-bg);font-style: var(--shiki-dark-font-style);font-weight: var(--shiki-dark-font-weight);text-decoration: var(--shiki-dark-text-decoration);}html pre.shiki code .stxUP, html code.shiki .stxUP{--shiki-light:#0000FF;--shiki-default:#0000FF;--shiki-dark:#569CD6}html pre.shiki code .sswaR, html code.shiki .sswaR{--shiki-light:#001080;--shiki-default:#001080;--shiki-dark:#9CDCFE}html pre.shiki code .sopvc, html code.shiki .sopvc{--shiki-light:#267F99;--shiki-default:#267F99;--shiki-dark:#4EC9B0}html pre.shiki code .swoLU, html code.shiki .swoLU{--shiki-light:#795E26;--shiki-default:#795E26;--shiki-dark:#DCDCAA}html pre.shiki code .smUd-, html code.shiki .smUd-{--shiki-light:#AF00DB;--shiki-default:#AF00DB;--shiki-dark:#C586C0}html pre.shiki code .s-S-M, html code.shiki .s-S-M{--shiki-light:#098658;--shiki-default:#098658;--shiki-dark:#B5CEA8}html pre.shiki code .sFD8J, html code.shiki .sFD8J{--shiki-light:#A31515;--shiki-default:#A31515;--shiki-dark:#CE9178}html pre.shiki code .sw10w, html code.shiki .sw10w{--shiki-light:#000000FF;--shiki-default:#000000FF;--shiki-dark:#D4D4D4}",{"title":328,"searchDepth":423,"depth":423,"links":1904},[1905,1906,1907,1908,1909,1910,1911,1912,1913,1914,1915,1916],{"id":303,"depth":423,"text":304},{"id":320,"depth":423,"text":321},{"id":370,"depth":423,"text":371},{"id":377,"depth":423,"text":378},{"id":727,"depth":423,"text":728},{"id":864,"depth":423,"text":865},{"id":1004,"depth":423,"text":1005},{"id":1118,"depth":423,"text":1119},{"id":1265,"depth":423,"text":1266},{"id":1754,"depth":423,"text":1755},{"id":1828,"depth":423,"text":1829},{"id":1847,"depth":423,"text":1848},"Use AutoFixture.Idioms to verify guard clauses and other coding idioms in your API.","md",{},{"title":92,"description":1917},"nxUS0sue-5AHu24UtnXS22DeAFr5zvGLVLnvQCX3uOQ",[1923,1924],{"title":82,"path":83,"stem":84,"children":-1},{"title":96,"path":97,"stem":98,"children":-1},1788856648640]