H transform translatescalerotatesaverestore saveRestoreclipRectclipPathrect clipRRectrrectdrrect rsuperellipseclipRSuperellipsecirclepathlinearc paragraphshadowimage drawImageRect something everythingincludesexcludesmatchesdescribedescribeMismatchmessagecallIntroductioncall_evaluatePredicates _methodName_count_nonPaintingOperations_filterCanvasCalls _predicatesmatch checkMethodtoStringsymbolname argumentCountpaintArgumentIndexcolor strokeWidth hasMaskFilterstyle strokeCap methodNameverifyArgumentsdebugFillDescriptionexpected expected1 expected2xyradiusp1p2 startAngle sweepAngle useCenter elevationtransparentOccludersource destination predicate _runPredicate arguments'paints paintsNothingpaintsAssertionpaintsExactlyCountTimesPaintPatternPredicate_ContextPainterFunction_CanvasPainterFunction _colorsMatch PaintPattern isPathThat _PathMatcher_MismatchedCall_evaluatePainter_TestRecordingCanvasMatcher&_TestRecordingCanvasPaintsCountMatcher(_TestRecordingCanvasPaintsNothingMatcher*_TestRecordingCanvasPaintsAssertionMatcher"_TestRecordingCanvasPatternMatcher_PaintPredicate_DrawCommandPaintPredicate_OneParameterPaintPredicate_TwoParameterPaintPredicate_RectPaintPredicate_RRectPaintPredicate_DRRectPaintPredicate_RSuperellipsePaintPredicate_CirclePaintPredicate_PathPaintPredicate_LinePaintPredicate_ArcPaintPredicate_ShadowPredicate_DrawImagePaintPredicate_DrawImageRectPaintPredicate_SomethingPaintPredicate_EverythingPaintPredicate_FunctionPaintPredicate_SaveRestorePairPaintPredicate _valueName _symbolNameImage Paragraph RenderObjectFinderPaintingContextOffsetMatcherSymbolint something everythingboolListdynamicpaintvoidCanvasColordouble colorSpaceaabsrgbexpect transform Float64ListequalsmoreOrLessEquals translatescalerotatesaverestoreclipRectRectclipPath pathMatcherdrawRectPaint PaintingStyle clipRRectRRect drawRRectdrawRSuperellipse RSuperellipseclipRSuperellipse drawCircledrawPathIterabledrawLinedrawArc StrokeCap drawParagraphwithin drawShadow BoxShadowMaterialdebugDisableShadows drawImage drawImageRectStringPathcontainsincludestoListexcludesoverrideObjectMapoffsetisEmptyjoin DescriptionlengthaddErrorRecordedInvocationfunctionzeroTestAsyncUtils guardSyncfinderevaluatesingle renderObjectresultTestRecordingCanvasTestRecordingPaintingContext StringBuffer invocationswritelnerrortoStringwritestack isNotEmptycall invocationisMethod memberNamefirst stackToStringindentwhere canvasCallAssertionErrormatrix4xyanglerectcolor strokeWidth hasMaskFilterstylerrectouterinner rsuperellipseradiusp1p2 startAngle sweepAngle useCenter strokeCap elevationtransparentOccluderimagesource destinationaddAllmap predicateIteratoriteratormoveNextcurrentmatchdatamessagecallIntroductions TypeError protected FlutterError runtimeType checkMethodpositionalArguments mustCallSuper maskFilterverifyArguments methodNamedebugFillDescriptionexpectedleftrighttopbottom blRadiusX blRadiusY brRadiusX brRadiusY tlRadiusX tlRadiusY trRadiusX trRadiusY expected1 expected2dxtoStringAsFixeddy isCloneOfindex substringMatcherError_TestRecordingCanvasMatcher PaintPattern_PaintPredicate_DrawCommandPaintPredicate_OneParameterPaintPredicate_TwoParameterPaintPredicate~̾qbU<#8Image Paragraph  ui dart:ui>package:flutter/foundation.dartipackage:flutter/widgets.dartpackage:matcher/expect.dart finders.dartrecording_canvas.darttest_async_utils.dart=ڀ߁ ;=hс.Tpr:"+0!r{҆ -2dž̇`bB2wz|ʉ bʊъڋ68nȋʌ KMuˌCi9\aQXBIؑ&p "bi S~`ʔ̕`35dkؖߖ=GhoǙ7JLC{ڛ 79t{ʜGN46jq Y`О07ПSZʠѡ o cCcFcHcocccddddfd{ddeee=e`eeffEfSfhfmf}ffffggPgghh,h7hphhhii iQigiiiij,jXjojvjjjk9kfkqkzkkkkkl1l3l@laltllllm mmmmjmmmmn nn n-n`nnnno.oBovooooppdpkppppppq(qrqwqyqqr5rWrkrrrrsss-s2s4ssst,tKtutttttuu'ukuvv8vlvvvvw#wEw\wewwwwxxExqxxxxy yRyyyyyyyyyz/zzzzzzz{{){0{i{n{q{s{{|"|$|1|X|||||}3}8}:}G}o}}}}}~7~<~>~K~\~~~~~ !9qvx0 6Rg~)v{}-Jax#6Ic}<cz"*@eO3Mhp<S]ejly,4Jf"*/1>M^o -Dg2E_y?^u Z1IiqCMUZ\iy/Pgv#;Qd|!8QtG Oo$1< #VkrNis!,Rz9|XdEGUK_~9F\hqx}8Wiy ":Pl QS` =XI_dftIdNi$+5AQn6Q5P 5g!#1C|=)I]q+-CER#q"?xDdx'Beg.d J*4;@BO7Gt}BKRWZ\#\_a#[]tv-G|(j0r9T(Vp)<Nf?azŒ¤¾*,9lÓ/Jĉ (aŏűC^kxƊƜƴ$8QS`ǓǺChȅ%.<mɊ!KW`ʑʮEo{˄ˋG̓.\Ͳ$<ΈΏΪ;Th|ώϦ#HJWЊб3bс4dҒұ&1:AFHUӎӼ?cԖԺRՒիչ GI^suւֵ"׆׍&Aؐg٘٢٩ٮٰٽ$;hoچڳںڿ+AWl~ۖ۰79VXrt܁ܴA\ݮ-pދ *1p߳cmt W&?el:jqvy{079^ :<J} ?\&GU`ip Xq*v2M*6Zdkpr+02@y SwKRz#Kl-K\iv)=?L"=+W|.:CQ7amv\7_f%.F1HZr -`m8[v!+279F;Bb:<I|Y (u)\ejl#t Lz|.]z $P > J S s x z     1         ! # \         5    " L V ]  13\NF!#cp+|$;>X~ SnS/// @docImport 'package:flutter/material.dart'; /// /// @docImport 'matchers.dart'; ! #8=hN.  _/// Builder interface for patterns used to match display lists (canvas calls). /// /// The [paints] matcher returns a [PaintPattern] so that you can build the /// pattern in the [expect] call. /// /// Patterns are subset matches, meaning that any calls not described by the /// pattern are ignored. This allows, for instance, transforms to be skipped./// Indicates that a transform is expected next. /// /// Calls are skipped until a call to [Canvas.transform] is found. The call's /// arguments are compared to those provided here. If any fail to match, or if /// no call to [Canvas.transform] is found, then the matcher fails. /// /// Dynamic so matchers can be more easily passed in. /// /// The `matrix4` argument is dynamic so it can be either a [Matcher], or a /// [Float64List] of [double]s. If it is a [Float64List] of [double]s then /// each value in the matrix must match in the expected matrix. A deep /// matching [Matcher] such as [equals] can be used to test each value in the /// matrix with utilities such as [moreOrLessEquals]. $XZZ!/// Indicates that a translation transform is expected next. /// /// Calls are skipped until a call to [Canvas.translate] is found. The call's /// arguments are compared to those provided here. If any fail to match, or if /// no call to [Canvas.translate] is found, then the matcher fails.e nmp yxF/// Indicates that a scale transform is expected next. /// /// Calls are skipped until a call to [Canvas.scale] is found. The call's /// arguments are compared to those provided here. If any fail to match, or if /// no call to [Canvas.scale] is found, then the matcher fails.  ΁c3/// Indicates that a rotate transform is expected next. /// /// Calls are skipped until a call to [Canvas.rotate] is found. If the `angle` /// argument is provided here, the call's argument is compared to it. If that /// fails to match, or if no call to [Canvas.rotate] is found, then the /// matcher fails.! *)7Y/// Indicates that a save is expected next. /// /// Calls are skipped until a call to [Canvas.save] is found. If none is /// found, the matcher fails. /// /// See also: /// /// * [restore], which indicates that a restore is expected next. /// * [saveRestore], which indicates that a matching pair of save/restore /// calls is expected next.>>Y/// Indicates that a restore is expected next. /// /// Calls are skipped until a call to [Canvas.restore] is found. If none is /// found, the matcher fails. /// /// See also: /// /// * [save], which indicates that a save is expected next. /// * [saveRestore], which indicates that a matching pair of save/restore /// calls is expected next.N''/// Indicates that a matching pair of save/restore calls is expected next. /// /// Calls are skipped until a call to [Canvas.save] is found, then, calls are /// skipped until the matching [Canvas.restore] call is found. If no matching /// pair of calls could be found, the matcher fails. /// /// See also: /// /// * [save], which indicates that a save is expected next. /// * [restore], which indicates that a restore is expected next.;/// Indicates that a rectangular clip is expected next. /// /// The next rectangular clip is examined. Any arguments that are passed to /// this method are compared to the actual [Canvas.clipRect] call's argument /// and any mismatches result in failure. /// /// If no call to [Canvas.clipRect] was made, then this results in failure. /// /// Any calls made between the last matched call (if any) and the /// [Canvas.clipRect] call are ignored.% ,+8ׁ{/// Indicates that a path clip is expected next. /// /// The next path clip is examined. /// The path that is passed to the actual [Canvas.clipPath] call is matched /// using [pathMatcher]. /// /// If no call to [Canvas.clipPath] was made, then this results in failure. /// /// Any calls made between the last matched call (if any) and the /// [Canvas.clipPath] call are ignored.ŢCC/// Indicates that a rectangle is expected next. /// /// The next rectangle is examined. Any arguments that are passed to this /// method are compared to the actual [Canvas.drawRect] call's arguments /// and any mismatches result in failure. /// /// If no call to [Canvas.drawRect] was made, then this results in failure. /// /// Any calls made between the last matched call (if any) and the /// [Canvas.drawRect] call are ignored. /// /// The [Paint]-related arguments (`color`, `strokeWidth`, `hasMaskFilter`, /// `style`) are compared against the state of the [Paint] object after the /// painting has completed, not at the time of the call. If the same [Paint] /// object is reused multiple times, then this may not match the actual /// arguments as they were seen by the method.O VU` hgs|{ɂ /// Indicates that a rounded rectangle clip is expected next. /// /// The next rounded rectangle clip is examined. Any arguments that are passed /// to this method are compared to the actual [Canvas.clipRRect] call's /// argument and any mismatches result in failure. /// /// If no call to [Canvas.clipRRect] was made, then this results in failure. /// /// Any calls made between the last matched call (if any) and the /// [Canvas.clipRRect] call are ignored. ؃ۨ00"/// Indicates that a rounded rectangle is expected next. /// /// The next rounded rectangle is examined. Any arguments that are passed to /// this method are compared to the actual [Canvas.drawRRect] call's arguments /// and any mismatches result in failure. /// /// If no call to [Canvas.drawRRect] was made, then this results in failure. /// /// Any calls made between the last matched call (if any) and the /// [Canvas.drawRRect] call are ignored. /// /// The [Paint]-related arguments (`color`, `strokeWidth`, `hasMaskFilter`, /// `style`) are compared against the state of the [Paint] object after the /// painting has completed, not at the time of the call. If the same [Paint] /// object is reused multiple times, then this may not match the actual /// arguments as they were seen by the method.= EDP XWclk}""3/// Indicates that a rounded rectangle outline is expected next. /// /// The next call to [Canvas.drawRRect] is examined. Any arguments that are /// passed to this method are compared to the actual [Canvas.drawRRect] call's /// arguments and any mismatches result in failure. /// /// If no call to [Canvas.drawRRect] was made, then this results in failure. /// /// Any calls made between the last matched call (if any) and the /// [Canvas.drawRRect] call are ignored. /// /// The [Paint]-related arguments (`color`, `strokeWidth`, `hasMaskFilter`, /// `style`) are compared against the state of the [Paint] object after the /// painting has completed, not at the time of the call. If the same [Paint] /// object is reused multiple times, then this may not match the actual /// arguments as they were seen by the method.0 87C KJV ^]iqp00;/// Indicates that a rounded superellipse is expected next. /// /// The next rounded superellipse is examined. Any arguments that are passed /// to this method are compared to the actual [Canvas.drawRSuperellipse] /// call's arguments and any mismatches result in failure. /// /// If no call to [Canvas.drawRSuperellipse] was made, then this results in /// failure. /// /// Any calls made between the last matched call (if any) and the /// [Canvas.drawRSuperellipse] call are ignored. /// /// The [Paint]-related arguments (`color`, `strokeWidth`, `hasMaskFilter`) /// are compared against the state of the [Paint] object after the /// painting has completed, not at the time of the call. If the same [Paint] /// object is reused multiple times, then this may not match the actual /// arguments as they were seen by the method.EUTh po{Fʁ/// Indicates that a rounded superellipse clip is expected next. /// /// The next rounded superellipse clip is examined. Any arguments that are /// passed to this method are compared to the actual /// [Canvas.clipRSuperellipse] call's argument and any mismatches result in /// failure. /// /// If no call to [Canvas.clipRSuperellipse] was made, then this results in failure. /// /// Any calls made between the last matched call (if any) and the /// [Canvas.clipRSuperellipse] call are ignored.GG/// Indicates that a circle is expected next. /// /// The next circle is examined. Any arguments that are passed to this method /// are compared to the actual [Canvas.drawCircle] call's arguments and any /// mismatches result in failure. /// /// If no call to [Canvas.drawCircle] was made, then this results in failure. /// /// Any calls made between the last matched call (if any) and the /// [Canvas.drawCircle] call are ignored. /// /// The [Paint]-related arguments (`color`, `strokeWidth`, `hasMaskFilter`, /// `style`) are compared against the state of the [Paint] object after the /// painting has completed, not at the time of the call. If the same [Paint] /// object is reused multiple times, then this may not match the actual /// arguments as they were seen by the method.U ^]e nmu~} 77/// Indicates that a path is expected next. /// /// The next path is examined. Any arguments that are passed to this method /// are compared to the actual [Canvas.drawPath] call's `paint` argument, and /// any mismatches result in failure. /// /// To introspect the Path object (as it stands after the painting has /// completed), the `includes` and `excludes` arguments can be provided to /// specify points that should be considered inside or outside the path /// (respectively). /// /// If no call to [Canvas.drawPath] was made, then this results in failure. /// /// Any calls made between the last matched call (if any) and the /// [Canvas.drawPath] call are ignored. /// /// The [Paint]-related arguments (`color`, `strokeWidth`, `hasMaskFilter`, /// `style`) are compared against the state of the [Paint] object after the /// painting has completed, not at the time of the call. If the same [Paint] /// object is reused multiple times, then this may not match the actual /// arguments as they were seen by the method.CVUdwv BB/// Indicates that a line is expected next. /// /// The next line is examined. Any arguments that are passed to this method /// are compared to the actual [Canvas.drawLine] call's `p1`, `p2`, and /// `paint` arguments, and any mismatches result in failure. /// /// If no call to [Canvas.drawLine] was made, then this results in failure. /// /// Any calls made between the last matched call (if any) and the /// [Canvas.drawLine] call are ignored. /// /// The [Paint]-related arguments (`color`, `strokeWidth`, `hasMaskFilter`, /// `style`) are compared against the state of the [Paint] object after the /// painting has completed, not at the time of the call. If the same [Paint] /// object is reused multiple times, then this may not match the actual /// arguments as they were seen by the method.N WV_ hgp xwل!CC /// Indicates that an arc is expected next. /// /// The next arc is examined. Any arguments that are passed to this method /// are compared to the actual [Canvas.drawArc] call's `paint` argument, and /// any mismatches result in failure. /// /// If no call to [Canvas.drawArc] was made, then this results in failure. /// /// Any calls made between the last matched call (if any) and the /// [Canvas.drawArc] call are ignored. /// /// The [Paint]-related arguments (`color`, `strokeWidth`, `hasMaskFilter`, /// `style`) are compared against the state of the [Paint] object after the /// painting has completed, not at the time of the call. If the same [Paint] /// object is reused multiple times, then this may not match the actual /// arguments as they were seen by the method. C# C*C)C4C=C<CMCVCUCfCmClC| CCCCCCCCCCCCCCDhG3G3/// Indicates that a paragraph is expected next. /// /// Calls are skipped until a call to [Canvas.drawParagraph] is found. Any /// arguments that are passed to this method are compared to the actual /// [Canvas.drawParagraph] call's argument, and any mismatches result in /// failure. /// /// The `offset` argument can be either an [Offset] or a [Matcher]. If it is /// an [Offset] then the actual value must match the expected offset /// precisely. If it is a [Matcher] then the comparison is made according to /// the semantics of the [Matcher]. For example, [within] can be used to /// assert that the actual offset is within a given distance from the expected /// offset. /// /// If no call to [Canvas.drawParagraph] was made, then this results in /// failure.G>GMGLGWG`G_GnPK"K"u/// Indicates that a shadow is expected next. /// /// The next shadow is examined. Any arguments that are passed to this method /// are compared to the actual [Canvas.drawShadow] call's `paint` argument, /// and any mismatches result in failure. /// /// In tests, shadows from framework features such as [BoxShadow] or /// [Material] are disabled by default, and thus this predicate would not /// match. The [debugDisableShadows] flag controls this. /// /// To introspect the Path object (as it stands after the painting has /// completed), the `includes` and `excludes` arguments can be provided to /// specify points that should be considered inside or outside the path /// (respectively). /// /// If no call to [Canvas.drawShadow] was made, then this results in failure. /// /// Any calls made between the last matched call (if any) and the /// [Canvas.drawShadow] call are ignored.K0KCKBKQKdKcKr KzKyKKKKKKKăNNł/// Indicates that an image is expected next. /// /// The next call to [Canvas.drawImage] is examined, and its arguments /// compared to those passed to _this_ method. /// /// If no call to [Canvas.drawImage] was made, then this results in /// failure. /// /// Any calls made between the last matched call (if any) and the /// [Canvas.drawImage] call are ignored. /// /// The [Paint]-related arguments (`color`, `strokeWidth`, `hasMaskFilter`, /// `style`) are compared against the state of the [Paint] object after the /// painting has completed, not at the time of the call. If the same [Paint] /// object is reused multiple times, then this may not match the actual /// arguments as they were seen by the method.NNNN NNN OOO OOOO$O#O5O<O;OOO_O^OqRR/// Indicates that an image subsection is expected next. /// /// The next call to [Canvas.drawImageRect] is examined, and its arguments /// compared to those passed to _this_ method. /// /// If no call to [Canvas.drawImageRect] was made, then this results in /// failure. /// /// Any calls made between the last matched call (if any) and the /// [Canvas.drawImageRect] call are ignored. /// /// The [Paint]-related arguments (`color`, `strokeWidth`, `hasMaskFilter`, /// `style`) are compared against the state of the [Paint] object after the /// painting has completed, not at the time of the call. If the same [Paint] /// object is reused multiple times, then this may not match the actual /// arguments as they were seen by the method.RRRR RRRRRR RRRRRS SSS&S6S5SHWWτ?/// Provides a custom matcher. /// /// Each method call after the last matched call (if any) will be passed to /// the given predicate, along with the values of its (positional) arguments. /// /// For each one, the predicate must either return a boolean or throw a /// [String]. /// /// If the predicate returns true, the call is considered a successful match /// and the next step in the pattern is examined. If this was the last step, /// then any calls that were not yet matched are ignored and the [paints] /// [Matcher] is considered a success. /// /// If the predicate returns false, then the call is considered uninteresting /// and the predicate will be called again for the next [Canvas] call that was /// made by the [RenderObject] under test. If this was the last call, then the /// [paints] [Matcher] is considered to have failed. /// /// If the predicate throws a [String], then the [paints] [Matcher] is /// considered to have failed. The thrown string is used in the message /// displayed from the test framework and should be complete sentence /// describing the problem.WWWX[[W/// Provides a custom matcher. /// /// Each method call after the last matched call (if any) will be passed to /// the given predicate, along with the values of its (positional) arguments. /// /// For each one, the predicate must either return a boolean or throw a /// [String]. /// /// The predicate will be applied to each [Canvas] call until it returns false /// or all of the method calls have been tested. /// /// If the predicate returns false, then the [paints] [Matcher] is considered /// to have failed. If all calls are tested without failing, then the [paints] /// [Matcher] is considered a success. /// /// If the predicate throws a [String], then the [paints] [Matcher] is /// considered to have failed. The thrown string is used in the message /// displayed from the test framework and should be complete sentence /// describing the problem.[[[]!#]']']I+]I]I]U]V ]\][]e ]k]j]z]]]]]]]]]]]] ]]]]`Ɂ```````bgbbb bbbbbb bbb bbbgbhcHcNcNcq@cqcqcc cccccc cccccccccd d ffff…ffffff ggffkWkkk"llll#l"l5lNlNle lnlmlxlll lll lll5l6mxmmml|mlmlmmmmm mmmmmmmmmmmn nnn"n;n;nDnQnPn"n#nǁnnn"o o ooonnp@pps6LsPsP sqssispsjsrsssyszpꀋqqq qqppq{qqq"qqqqqq{q|sȁsss(tttֆttuu.u.u6u?u>uF u]u\uuyz z zz zyyzzzz zzzzzz { { { { {zz{sz{y{y{={{||| || |&|8|8|C|L|K|&|'|||| ||| ||||}<~}N}N}U }^}]}` }i}h}<}=}z}}} }}}}~@b~R~R~@~A~h~~~~^((zz z{   i     o   ' /.: BAMVUgnmm  -=<    &%7>=Qa`n %$no3EEQ ZYb kjs {z34J  '&6 >=IRQcji}""-<;FON" *)5>=MTS^pp}     ^_**?JIU \[hon ~#:9**3@?H". !>=I2\\h! IJk:::T [ a`m sr}   $11<IIR\\nxx"---U ggm!UVhhivw ''%JJ_ml%&34ބ+++FM UTa ihu'#&/88GcYYixwGH=dFFFah po| +;:INaOW]`issDVVkyxDE\bb    */X01;RJTaEgg   */W01<SV_llxfxy䀿 H "!- 54@ GFRYXjqp  AAA]ekj~ …„—–¨¯®".@@P_^.///DRQEEEZbhgout| ƂƁƎ ƕƔƠƧƦƸƿƾ     &44:HHUggwdžDžUV ===PX ^]l rqπ χφϒϙϘϪϱϰ  % ==L^^n}|LMJ\\q~JKRnXXՔՔՔէկյմս  $)C*+5?BKYY`nnw5։։֧֙֨wxٲ ٲٳĈ  %$/54EKJ[a`p wvۂۉۈۚۡ۠۴ ۻۺ**;IIZffv8܈܈ܘܧܦvwᴁ{i㯀   ; SS` xx( ->0QQapo>?t!tu4GG\ji45ρ舷///GO UT`femsrz    %%+99AdSScrqAB  # )(5;:L SR^edv}| "44DSR"#;eMMbpo;<f)%..>*PPV!ts>?n_ss7N*NNghnm~%! |a         9     # ) ) ^5 ^ ^ u v  | {          ׄ   !    '  #))egww}!efAr///// Matches objects or functions that paint a display list that matches the /// canvas calls described by the pattern. /// /// Specifically, this can be applied to [RenderObject]s, [Finder]s that /// correspond to a single [RenderObject], and functions that have either of the /// following signatures: /// /// ```dart /// void exampleOne(PaintingContext context, Offset offset) { } /// void exampleTwo(Canvas canvas) { } /// ``` /// /// In the case of functions that take a [PaintingContext] and an [Offset], the /// [paints] matcher will always pass a zero offset. /// /// To specify the pattern, call the methods on the returned object. For example: /// /// ```dart /// expect(myRenderObject, paints..circle(radius: 10.0)..circle(radius: 20.0)); /// ``` /// /// This particular pattern would verify that the render object `myRenderObject` /// paints, among other things, two circles of radius 10.0 and 20.0 (in that /// order). /// /// See [PaintPattern] for a discussion of the semantics of paint patterns. /// /// To match something which paints nothing, see [paintsNothing]. /// /// To match something which asserts instead of painting, see [paintsAssertion].bL/// Matches objects or functions that does not paint anything on the canvas.NND/// Matches objects or functions that assert when they try to paint.\/// Matches objects or functions that draw `methodName` exactly `count` number /// of times.$ )(MFRR_fehpo[ɁT\h\h/// Matches a [Path] that contains (as defined by [Path.contains]) the given /// `includes` points and does not contain the given `excludes` points.\x,\\\,\\ \\\\\\\\\\\\diddd+d4d3d; dCdBdJd[dZ!!, 54 |P/// Signature for the [PaintPattern.something] and [PaintPattern.everything] /// predicate argument. /// /// Used by the [paints] matcher. /// /// The `methodName` argument is a [Symbol], and can be compared with the symbol /// literal syntax, for example: /// /// ```dart /// if (methodName == #drawCircle) { /// // ... /// } /// ```*)8vv4/// The signature of [RenderObject.paint] functions. ?/// The signature of functions that paint directly on a canvas.: BApackage:flutter/material.dart matchers.dart=ڀ߁ ;=hс.Tpr:"+0!r{҆ -2dž̇`bB2wz|ʉ bʊъڋ68nȋʌ KMuˌCi9\aQXBIؑ&p "bi S~`ʔ̕`35dkؖߖ=GhoǙ7JLC{ڛ 79t{ʜGN46jq Y`О07ПSZʠѡ o cCcFcHcocccddddfd{ddeee=e`eeffEfSfhfmf}ffffggPgghh,h7hphhhii iQigiiiij,jXjojvjjjk9kfkqkzkkkkkl1l3l@laltllllm mmmmjmmmmn nn n-n`nnnno.oBovooooppdpkppppppq(qrqwqyqqr5rWrkrrrrsss-s2s4ssst,tKtutttttuu'ukuvv8vlvvvvw#wEw\wewwwwxxExqxxxxy yRyyyyyyyyyz/zzzzzzz{{){0{i{n{q{s{{|"|$|1|X|||||}3}8}:}G}o}}}}}~7~<~>~K~\~~~~~ !9qvx0 6Rg~)v{}-Jax#6Ic}<cz"*@eO3Mhp<S]ejly,4Jf"*/1>M^o -Dg2E_y?^u Z1IiqCMUZ\iy/Pgv#;Qd|!8QtG Oo$1< #VkrNis!,Rz9|XdEGUK_~9F\hqx}8Wiy ":Pl QS` =XI_dftIdNi$+5AQn6Q5P 5g!#1C|=)I]q+-CER#q"?xDdx'Beg.d J*4;@BO7Gt}BKRWZ\#\_a#[]tv-G|(j0r9T(Vp)<Nf?azŒ¤¾*,9lÓ/Jĉ (aŏűC^kxƊƜƴ$8QS`ǓǺChȅ%.<mɊ!KW`ʑʮEo{˄ˋG̓.\Ͳ$<ΈΏΪ;Th|ώϦ#HJWЊб3bс4dҒұ&1:AFHUӎӼ?cԖԺRՒիչ GI^suւֵ"׆׍&Aؐg٘٢٩ٮٰٽ$;hoچڳںڿ+AWl~ۖ۰79VXrt܁ܴA\ݮ-pދ *1p߳cmt W&?el:jqvy{079^ :<J} ?\&GU`ip Xq*v2M*6Zdkpr+02@y SwKRz#Kl-K\iv)=?L"=+W|.:CQ7amv\7_f%.F1HZr -`m8[v!+279F;Bb:<I|Y (u)\ejl#t Lz|.]z $P > J S s x z     1         ! # \         5    " L V ]  13\NF!#cp+|$;>X~ Sn$paints paintsNothingpaintsAssertionpaintsExactlyCountTimes _colorsMatch PaintPattern isPathThat _PathMatcher_MismatchedCall_evaluatePainter_TestRecordingCanvasMatcher&_TestRecordingCanvasPaintsCountMatcher(_TestRecordingCanvasPaintsNothingMatcher*_TestRecordingCanvasPaintsAssertionMatcher"_TestRecordingCanvasPatternMatcher_PaintPredicate_DrawCommandPaintPredicate_OneParameterPaintPredicate_TwoParameterPaintPredicate_RectPaintPredicate_RRectPaintPredicate_DRRectPaintPredicate_RSuperellipsePaintPredicate_CirclePaintPredicate_PathPaintPredicate_LinePaintPredicate_ArcPaintPredicate_ShadowPredicate_DrawImagePaintPredicate_DrawImageRectPaintPredicate_SomethingPaintPredicate_EverythingPaintPredicate_FunctionPaintPredicate_SaveRestorePairPaintPredicate _valueName _symbolName7x