mcs/class/System/Test/System.ComponentModel/MaskedTextProviderTestGenerator.cs

   1 //
   2 // System.ComponentModel.MaskedTextProvider test cases
   3 //
   4 // Authors:
   5 //      Rolf Bjarne Kvinge (RKvinge@novell.com)
   6 //
   7 // (c) 2007 Novell, Inc.
   8 //
   9
  10
  11 // a reference like this is required:
  12 // -reference:MS_System=<gac>\System.dll
  13 extern alias MS_System;
  14 using System;
  15 using System.ComponentModel;
  16 using System.Text;
  17 using System.IO;
  18 using System.Reflection;
  19 using System.Globalization;
  20 using System.Collections;
  21 using System.Collections.Generic;
  22 using System.Threading;
  23 using System.Diagnostics;
  24 using MS_System_ComponentModel = MS_System.System.ComponentModel;
  25 using NUnit.Framework;
  26
  27 namespace MonoTests.System.ComponentModel
  28 {
  29         class MaskedTextProviderTestGenerator
  30         {
  31                 const int MAXFAILEDTESTS = 100;
  32                 static string [] test_masks = new string [] {
  33                 // Misc
  34                 "abc",
  35                 "aba",
  36                 "abaa",
  37                 "a?b?c" ,
  38                 "09#L?&CAa.,:/$<>|\\\\",
  39                 // Social security numbers
  40                 "000-00-0000", "0 00 00 00 000 000 00", "000-00-0000", "000000-0000000",
  41                 // Zip codes
  42                 "00000-9999", "00000", "000-0000", "99000",
  43                 // Dates
  44                 "00/00/0000", "00 /00 /0000",  "00 /00 /0000 00:00",  "00/00/0000 00:00", "0000-00-00 90:00:00",
  45                 "0000-00-00 90:00", "0000-00-00", "00->L<LL-0000", "90:00", "00:00",
  46                 // Phone numbers
  47                 "(999)-000-0000", "00000", "99999", "00 00 00 00 00 00", "0000 00000", "99900-9990-0000", "(900)9000-0000",
  48                 "(00)9000-0000", "(999)9000-0000", "000-0000", "9000-0000",
  49                 // Money
  50                 "$999,999.00"
  51                 };
  52
  53                 static int tab = 0;
  54                 static StreamWriter writer;
  55                 static bool dont_write;
  56                 static char [] char_values = new char [] { char.MinValue, char.MaxValue, 'a', '/', ' ', '*', '1'};
  57                 static int [] int_values = new int [] { int.MinValue, -1, 0, 1, int.MaxValue };
  58                 static string [] string_values = new string [] { null, string.Empty, "a", "a longer string value", new string ('z', 1024) };
  59                 static MaskedTextResultHint [] hint_values = new MaskedTextResultHint [] { MaskedTextResultHint.AlphanumericCharacterExpected, MaskedTextResultHint.AsciiCharacterExpected, MaskedTextResultHint.CharacterEscaped, MaskedTextResultHint.DigitExpected, MaskedTextResultHint.InvalidInput, MaskedTextResultHint.LetterExpected, MaskedTextResultHint.NoEffect, MaskedTextResultHint.NonEditPosition, MaskedTextResultHint.PositionOutOfRange, MaskedTextResultHint.PromptCharNotAllowed, MaskedTextResultHint.SideEffect, MaskedTextResultHint.SignedDigitExpected, MaskedTextResultHint.Success, MaskedTextResultHint.UnavailableEditPosition, MaskedTextResultHint.Unknown, (MaskedTextResultHint)(-1) };
  60                 static CultureInfo [] culture_infos = new CultureInfo [] { null, CultureInfo.CurrentCulture, CultureInfo.InvariantCulture, CultureInfo.GetCultureInfo ("es-ES") };
  61                 static object [] object_values = new object [] { "a", 1 };
  62                 static Type type_Mono;
  63                 static Type type_MS;
  64                 static Type type_Hint_Mono;
  65                 static Type type_Hint_MS;
  66                 static Type type = typeof (MaskedTextProvider);
  67                 static ConstructorInfo [] ctors = type.GetConstructors ();
  68                 static MethodInfo [] methods = type.GetMethods ();
  69                 static PropertyInfo [] props = type.GetProperties ();
  70
  71                 static List<ConstructorInfo> ok_constructors = new List<ConstructorInfo> ();
  72                 static List<string> ok_constructors_statements = new List<string> ();
  73                 static List<object []> ok_constructors_args = new List<object []> ();
  74
  75                 static char [] [] add_char_test_values = new char [] [] {
  76                         new char [] {char.MinValue, char.MaxValue, 'A', '1', '+', '*', '8', '?', '@', 'A', 'Z', 'ñ' },
  77                         new char [] {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j' },
  78                         new char [] {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'},
  79                         // Some randomly generated characters.
  80                         new char [] {'\x26CC', '\xFE68', '\xB6D4', '\x8D66', '\xE776', '\x786F', '\x78E9', '\x12E4', '\x1B02', '\xFFC2', '\x5846', '\xF686', '\x438B', '\x2DE2'},
  81                         new char [] {'\x5B83', '\xC320', '\x570', '\xE07A', '\xD42D', '\xF21C', '\xEA4', '\x1113', '\x2851', '\x2926', '\x706D', '\xD59E', '\x8CCD', '\xC5DF', '\x7223', '\x7F75'},
  82                         new char [] {'\xC5E6', '\x5FE2', '\x61C0', '\xAB57', '\x8C1', '\x50D0', '\xCE1B', '\xABBF', '\xB7C7', '\xDB6F', '\x2DC3', '\xCF99'},
  83                         new char [] {'\x89A1', '\xB987', '\xD18D', '\x727E', '\x35BE', '\x19EF', '\x6D02', '\xF4A5', '\x79F4', '\xC7A0', '\x1827', '\xED54', '\x8E82', '\x643F', '\x7709', '\xA2D0', '\xEC1B', '\x4D04'},
  84                         new char [] {'\x804C', '\xB3AA', '\x309F', '\xE3A8', '\xCC22', '\x217C', '\x52C1', '\x7250', '\x3754', '\x34BB', '\x1C65', '\x16AC', '\xE0E1'},
  85                         new char [] {'\x4088', '\x9F85', '\xB6E5', '\x411', '\x1A4F'},
  86                         new char [] {'\x5833', '\x1273', '\xAFF6', '\x4BF2', '\x9841', '\x4998', '\xBE02', '\x7A3E', '\xEC91', '\x5712', '\x8EE'},
  87                         new char [] {'\x8E6A', '\x84E4', '\x4F4C', '\x341E', '\x5901', '\xD5DE', '\x56B', '\x5101', '\xE2FC', '\xA79F', '\x35AD', '\xBFE9', '\x5D8E', '\xB0F4', '\x3746'},
  88                         new char [] {'\x4DFA', '\xC4BA', '\xC023', '\x9EBE', '\xD1CC', '\xBCE3', '\x50AB', '\x6DD9', '\x3B3', '\xE4AD', '\x4B66', '\x8289', '\x6379'},
  89                         new char [] {'\x85BF', '\xE041', '\x2BCC', '\x50BA', '\x8842', '\x5BFD', '\xF22E', '\xC6A', '\x4684', '\xE106', '\xFEA6', '\xC94D', '\xAD24', '\xB093', '\xDCC6', '\xF00D'},
  90                         new char [] {'\xE74D', '\x1252', '\x1228', '\x2C44', '\x27D6', '\x96EF', '\x6A2F', '\xF9DE', '\xD186', '\x3438', '\xE173', '\x306A', '\x7453', '\x8A77', '\x82E1', '\xED88', '\xA79', '\x21E0'},
  91                         new char [] {'\x941C', '\xCD3', '\x28B1', '\xDB49', '\xB9AB', '\x418F'},
  92                         new char [] {'\xDF1C', '\xA018', '\x87F', '\xFBF', '\xA018', '\x9112', '\x13A6', '\xF64A', '\x6418'},
  93                         new char [] {'\x5150', '\xAC3E', '\x5DE8', '\x4952', '\xC19D', '\x56DC', '\xB6BB', '\x27C5'},
  94                         new char [] {'\xDBFF'},
  95                         new char [] {'\x568E', '\x7BC4', '\xDBC4', '\xA2AA', '\x8EB2', '\x875A', '\x5BF0', '\xE18F', '\xBE9B', '\x3709', '\x587C', '\xEAB4', '\xA9A0', '\xB7D2', '\xCA17', '\xF15F'},
  96                         new char [] {'\x941F', '\x5060', '\x1CC4', '\x7E09', '\x265E', '\x12AA', '\x9C37', '\x5E3B', '\xC3F8', '\xC19', '\xD27F', '\xB5F7', '\x71F6', '\xB383', '\xA8F1'},
  97                         new char [] {'\xAC05', '\x888D', '\x2453', '\x2CBA', '\x6D14', '\x1165', '\x9B8'},
  98                         new char [] {'\x14BA', '\xA57D', '\x392E', '\xF8D3', '\xC189', '\xB447', '\x917F', '\xF786', '\x657C', '\xF4F3', '\x93A5', '\xC05A', '\xBF3B', '\x5427'},
  99                         new char [] {'\x691A', '\x3F8C', '\x446F'},
 100                         new char [] {'\x7B40', '\x8970', '\x2B97', '\x4CA5', '\x8385', '\xAF8B', '\x8524', '\xFD9A', '\x2F45', '\xA5C3', '\xC4A4', '\x54B2', '\x82BA', '\x46A7', '\x650D'},
 101                         new char [] {'\x80E1', '\xD97B', '\xA363', '\x9CB1', '\xFB0', '\x7A9A', '\xDAF9', '\x507A'},
 102                         new char [] {'\x1FDE', '\xE896', '\xA655', '\x57DE', '\x585D', '\xBB39', '\xED2D', '\x28A5', '\x46AA'},
 103                         new char [] {'\x2E45', '\xE923', '\x58D8', '\xB5A9', '\x4948', '\x3C65', '\xB6AC', '\x623A', '\x51C2', '\xA0D8', '\xA041'},
 104                         new char [] {'\x79B3'}
 105                 };
 106                 static int [] add_char_test_char_count = new int [] { 1, 4, 7, 9, 6, 4, 3, 2 };
 107                 static string destination_file;
 108
 109                 static string [] [] add_string_test_values = new string [] [] {
 110                         new string [] {"", "a", "abc", "`pasdf", "1297.1243,5132", "1", "€", "%", "$", "123", "AMKHJ"},
 111                         new string [] {},
 112                         // Some random data here too.
 113                         new string [] {@"ꬡ鞱딅鷔疢삹﬊かꄶ椩쥀申ᗱ賵᠞ĕ릇Ā냲㰖챦蔖随暣酿盐㠫���", @"ꁀ⇽⭼⧻", @"❍婝꽦䝶Ꞁ鞈⇳鄉⾮쭬⠪＋邶Ͳ䍇쟤쵾", @"절☋ġ乢౔ﻒ袍ὰ᨟õ䜬鷃䬸담斨", @"ꚸਠ릉ॲ꒎ꩲ曡鬷楔", @"ꝵ���틥���⹕巽���髴ł௻ꌑ䢤Ỳ砗ߔ逓ⶨ���䰖⬎칧", @"뷄㨞쐌ꭳᶖㇾ驀댫ꌀ蜍䝉䜹⢚ᣗ㿅焾᠀摥匚骼朎烥ⱶꊝ揹繟涎象", @"籧ী㙕᪗駱⺆絞", @"䞱壐\11솗㷙ノ삚杹쾫殳㐖욨筌ǒ嚵줹���综竸츅ᯠ䖜᚞孞撱㶈ფฃ⒠ꗔ䊸骢锡୨䇬曼꽍겥ﮧ", @"ﱿ꺴羪₭떾蹳㒂쏡⫽쁤꾊ɥľ⯐ጳ昹���꾶奶ꬊ䠎⣻饳ㆆ濣뿦᧫⳦荔飵톅洬엱揆껲꼔���䨡念"},
 114                         new string [] {@"頽鏢���⺸綉䤔퍽ࡡ㉌ꌉΩ㞜帤萸ẏ璜퐨ᄑ鍾ⰵ楯⾹뺤䵁ɳ⨵", @"퍕པ녧抟闍Ķ鶣遌鄭爯탖奩竳", @"⹻概蹕︾֡⪺邅柅痹凱書⻍搩⃳訅䚡ꥇ쐰", @"鎵剂퓼懤峮蹃懹䀺㨔녂˅ľ唢뻫ﳑ", @"뎫殐饛죖Ⴍ⻕퉨㥺潙꾶訵뀡뛂޲髅ᝀ류鱙ꢳ䐥Ɂ葖᏿ꡖៜ떶Ⰸ拪쯐⊋铀䧏꧌ႄ署襫쑏㌏誅괚Ừ㎷秏똅觳奔ﬓ", @"㷡֓士吞뭕녪蕛ⁿ礞Ꙡ횏ꎈ贫卩䁥ٔ꘾ᑋ", @"跔楊ḭ霋傟騰跩묶ヵﱱ路᳸㯕弚భ瓾棫쭾맰횋筢Ꚍ♦疟莞", @"옍뀍ႉ㗰⑊츒隚⸮櫧뷨畫���ᖘ", @"ន䪴៝䜣ࠞ⭬ⓨ⦋꽙㨉쁿柵ꨒ珊粱੊曵䨭㙤���౮", @"뿀쨬鄇疒觔㪽悗ﰈ溸ﱭ旉㙙໒⫫", @"ഝ���骠謤䁇ﯧ揊昝睠녽悜図⬽ꎸ㞶揄쭠諴䶱", @"銋ꆘ죳덑쭐쐒ȫ玹擷凅麊姗殄鯄劽╰௬쏘晡⫪褋ታ褿￺ꔕ䍺墴⸒튔䍲鿷ḏ圁䰝", @"ꃸḊ賶゗龸揱磎ቨ徸숒ﴛ뾹ߴ㹔뽳윛謱ঀ輤惬죹฻蟕歝퐘ꄤↅ뇎聺˕ὧꊼ뇅ݥ绶鍁용웸ွ\v⦇㷨ꟹ菁僀䤚", @"菾���㚿쯏䊝槣䀌唑纺ꣁ㑚还힩귩䆗海ꁑ攸㌳㛮䁽㏙₦쐹弄輙㝥", @"時Д᪜諾ೣ鶆���䦻㜅���㣙熹뉔<鉎㜟㢓༨箝ﱐ궳ᗦ嵒䎁", @"ᘙޖ䥚���ࢧ짿ᡸ꒭ᦾӚ쫅卜퓸썀쎇ⱞ셺蒙䁁䥘蹗贙삯翱믇軀뢎₣⼔甘꾑", @"㏯㎡⽯鍰帐椒䗓碐㉅淍믌ꚥѴῨ"},
 115                         new string [] {@"Ø[zZL;_êù¡Ä0ÎXXZ", @"ÄÎo ÖVØ«´Á¢RÂ@V", @"ðü<ªXq57°zoD¢ÈÞ%Ë<ïÐA¸Jw$¬9Ôläüö>3<'wÊ%¿MÚêg5(", @"rûJ©öHÞIP^WóÚtòáÒ""ÿF", @"dMÑiO-×ÛÌèd)ôI.zÇ", @"ZÿuâCUD+¢å\$Þ°]þ7]¸Þ", @"ÑÌüòÒVÚK\$fPÁuºÉ@ÌüÜFµúwkI_èiR´ÐTb4=èÉ¿Q0ö", @"zÂ¦)ïäw@dBtÝïÂD/®/FM\¸sñË®9E(ÅV}è<|t5Vw", @"Aíã¦b*1wÆ¤RÆüî¬0FEq6ÎI lqØ_t7V×sÝÏÈÐE@Gå&0Ð`", @"\A¿¦µMO5${Ïu´3yÚ+_yM31÷^ÙM9öìÌ©'-Øãg`;´-N:e", @"åÍöã rÄc;]Orn¯N±îÚ¿¯Ç×""Á}GÓAìq", @"Q×x*Í±È¶Ò¶d;ÐK±îýÂ®:ÕìÖ±âßu%ãzX9<<ï2iDÂ¿Ùóïá22", @"T0Ä»G.èÍs¤rþÀmÂî#5ðïÝ;ÇHF7", @"µ"},
 116                         new string [] {@"nýÖ3euj|!þbÄOp@¬ËióX+^QiHØK¿ÅYLâÐzs", @"e÷#úE¡~Âá~-:P", @"%ºÂNÅþ", @"&ÙÆ§g-o^ZÝ2Î´c_óù", @"N~mi7¶S¸ÃlÇ¸¯ë¤LÂÊ'Vô", @"¸bjù3ßYQ)ùÄ7M¡ÆTÅñ&¨º¦7¡ÀWhBÜVX9è_;i¶&lÿ¶)", @"ÒÞ´®Â>¨·Ñâ\ôppKmÄ·êýN¦xùXd(æ§R¬@§ªÓÊwE", @"Y'È±Aðæ'>L\H¤ØrßÈ@)¶Ö:wQ=_ËõSbÆiJvÆçF»9&=Ïì", @"ùÕÜRè®¯¥.¸ðîÐaÛZ%Ö´mÈHö,Æt^üýrZ", @"Õ+ÿl@Ûú-A»È""ÞDÝYr×", @"PM|V.÷", @"=zugLòIBÂêDÑéi»©4zª«+ÂYØÊÿgò%Ýb{7=ÙqJ", @"ÖÑã]ì·?µ¿H:lOUßgYÜÞÑ", @"[]vÐ`Áì=WønPî(w£3äËík|?¢µÁYÈÎ¶", @"[ýV¡KÙùí¶¤-hv´þõ¿oý´CHtÀ¥×ç¶zÑsRìäXÈ@À>ë`eäÍ(ãÚñ:"},
 117                         new string [] {@"µüÇ1ðYLGðÿfëçVáÎòÃÇ", @"íNßpïTâr9Ç8ãnX6ÉÍùÞünJäißåß", @"ê9CÆÍéPjyèõmædÁÄÒâRyÒyÏpòÃäVDÿKÅÏ"},
 118                         new string [] {@"ORüióíSDçwÞttyXñûNipá3iýúJÄN59è0Öy", @"û68UBnòÐLâòOVKYOæÌÎëÑjUìEâuFz", @"GtÝénäWÕÝWÀõiM7biQDIëwýÖâþ", @"dÓïØÉ6ÙìÊÎiò6ºÖjpÓÌyzpþèöñõxÔá4OõÝY"},
 119                         new string [] {@"vóAÏÿð3", @"ÎmÊèòè8øî2òv9", @"WNæXÔÓudCµMÇ0é5ÞÝáJãU7i7LãÔÏêoìÂrÕÚáyòõîÛãî", @"LzPZÐoñÝjÙì", @"ºOôd31éZ8BÒÂyµÍnfSDzçv6ÖÅæÓwüWëËÃAAHyjïÌ", @"ÚBßxiEäÆLÀõ9mmHqÉ", @"µW2RMw", @"ôòùÖnïJDÒáKÌÃ5kZæªßÜÞ4ctÕzÚÄÈ", @"õaíiwËdìÚHMÒI2ßÔ2ã4ºSP", @"W252ªÜsºâSDèF", @"RæØwXÂrsuövªb3wÎâØuÑGúS5Ò7ÓBÛvöYGóYû", @"FòùßmwQùMPÿÆzø8û1éCÇÚrgµýîFÝZúªòmxåOYÄÇÆ2VÉpCë62", @"à", @"SþîzhmÎäìC3oBÌêQhã0s4hïOjÉïôÑ", @"ÝXRææO6Ì", @"ËtqïcµìVÿCÌ8Ä7ÀWGw5äpÊ0ËùÀûYé", @"ËiÜÔë1nëkfæÞÜ61ÝõÑÊîè8ËßÇýuÊWñâçú7yäX1sÐÔq9iÿ", @"ÙÃçÙüVQºÜÃÅãÏÙG"},
 120                         new string [] {@"ú84myÅÜéNVØEÃÛmÅæEtQDî0Y3ònësîÑKêòtÇûËÐ", @"iÍäáóSnÇÍkµìÄBtu9zápÜäwiùkhã", @"àÖGÛõ7ÙcAÏÌ86Ïfj2zgïVÌÇ3ì85ÝèJÂ3gqÂôsëJC", @"ºcíJÖðrîoKUI73º2ºVÀ7äxOÂýùêöEÇTæ6ÉÊdÖVîüLÒ7tl", @"ahÀ3VüïpÙtWÜqÁlMûBÆNaMûzàQTÄ", @"ÇGÜwæ7õZè4ÇuÉQOPËlªÞüÒNMÞtDh", @"XÍîîgÙoLàÜÇÝ7ªÆrÒAbdæÍjuïöygBÌÜîÉDJÍÄé8æö"},
 121                         new string [] {@"ü7ÀpöYÚJÕwOnqpW9", @"ÙÖaÆÎSÉþSÞjdr5çÈsXBÖÂMÎs0DËeGRºwÐâäh13væ", @"ÔäÓàVAñgcu3CöÛæÜzKYYòéKÿkmÐûQznõ7XAy"},
 122                         new string [] {@"ñAÚäéÈÕúÇÅßûULÞxtKáâVÚùOÈâÄKÐ1õûàåpçòWÊêFÃèö0Fõh", @"nä6æE", @"qªèrYº5z6ÊkoiDäÓ0q", @"ävm6VzÖItXÈôÈéiÎiÑZHK0Ó1LK9Z", @"FUÿ", @"YÒàXÏIæAÜGPõµÝLkâÑñúðäF", @"x7ÝÅbçëVÔxííOÒ9Miî8é0bÔæE", @"µÕþ7öMTÔýtÁgÜÏswðiB6éýÁºnÊÊÉµÁl8", @"ÒbÏïëèËßÏïÃÊmäø6ÎþïAI5çHü4oúßkéÆ8íùÎÓSÆ", @"ÊÐèüGÔÙyÁZaññÓÐØKØÁHÚoo", @"ÀLé9ÑÖtPASJòrWàcaÄóêõçXëeÃë84rGXmvxeNühTÃhV", @"sÌGqªûôôxYçÀërtÐÞçzÔºÁðûÛËÒw", @"WvjHùæÕßgßbÅOkþèÛäÂÕ", @"úðpjZÏÁÚYÈhÔrÇÑ", @"úðëäÌöÛµ34cpCsÝçìÀÄÑîtãªâã5ün"},
 123                         new string [] {@"57gÊÍÁsEækPdyd9RòÒ3QNQF", @"rØUG", @"cüîTîaòouøåØöñÚvñäÕºßcýôbðºÑLbÀwµãçjè", @"ºçüÊ7òhÎnOâYö9àéX", @"eINõFÐãSû0oªPëÓÄxÿçyííCæÜp", @"âÎyuÕörxéiMi", @"0êqtNëÙáÿöøCWBÃPÜOÎåBÌÑÒÃ1yØîôSîýP6ýøGQûÐªoÕsÍ", @"HIbÃïòzòKA7òq5CoÓwaÑAj99WbUÜãéÄ6rÐÕ", @"âDzoñÌÄTyYÔîÐÄUiVº6NFåêÂéÉÙþKÇÞ", @"ËcbÈnRtuÅVâogÆJwÊfeA06ÜtjfLäí74ÆzúmüÐä", @"Õ2FIðEaÊfªcþÓKgüt", @"ºnÁpõ", @"5ËÉóXÞmqrNá3xLÌYÇMÃÉAHkýïÝmÁÃYðjBCârærÄG", @"VdÏvMXçdúHYxëaeWÌàÄ3k", @"BÿPhÇùuòdãçwÕrC7pRÉTû9JÙyOVðËÌÞVuoædçIÎ9ùg", @"8ê", @"ýcàµRCÅyÄáÀöNïgÛIÞQåÉæKHøAÙBÍ9EWVºç3ÖÁXàÊWPmB"},
 124                         new string [] {@"jîI", @"BºåfûÊkuÞCÿj7NÖE2PåÊù41päòá", @"kfÞåsø5ªòã4LÅ5lúnÞr5KhDuKÛXáYGïÀ", @"FNàãAJGüÞÃéntßÅSéÜaJátdçkEýrDÖpÙzEÅgöh7ûz", @"wÄÐÛOÚØÖÚÞ7XÚIÓúòõmh2Qñ4ÏtçWWámÜÎ5òÇðªUXèT", @"åLãZÉvg52ùBù2ýèAIÞhë6TýÅÙÂTºâÝVýÝòÛÝÕ", @"UpíD4Ç", @"ìéÇSõa4", @"úcçýúìÎ01ÔÕ", @"fuùìàLÉsßùµÊËIãôwjqéµÝLÉI", @"ÐÜÉÌaZuõYÛçì5ÑôÿããKNçVaQÀ1ÛSõÇÕu0VÃIVjVe3ÎZVæÈHÜT", @"UbÍPâopoHxâËAq", @"m", @"UÔÏÏÑhÝÜÃæuYRÎÕTºfxMJQ7ÓDªIJçúêÁxJÕvþçÿjÐbßºýQCEË", @"ÕAA0étiBÀKuñçµGÌ7wÅkÙyaDwAÆÍTµuÌåsq4PÀæE"},
 125                         new string [] {@"9eúRÏóÊìÚÆw0W1Í5ÎwÁûñåàöáwábÍxåþSF", @"ÎIJwßfÛëWÃyFMájt6j8sòÝùÎuØ8qcÅI1Â6ØìþOíWÅÁGÞÀÛø", @"ì9ÈuÍGá", @"ü3aICoSîFùüóuÙJâëøwåzÒ8", @"KµµÉÁÆMîàZÚõÑÙlGcDOrqLÀRã6k2ÛPáÓKÔíìªöÝÄP", @"mBOdÁ5e989kónHØòzã9Gýûðn0", @"IqhqáFj5ÎºcñïIàOdÂÙx5êåqïfxÌÚÀð", @"ôÂY7ÕNRÍ5ÆPMÐHàvÆÃÒCöIÊà1GêDP", @"QsI", @"ô7âyLIúÅjgCrð0ñQTúúIvnßÀDoóEÃqboHd8azÏ", @"æýxJº6YæiÈoÿ0ëªSuãß9ÁöiÉÉQÂaaSUPEGvOx", @"Õ", @"Znú3üð", @"FÄÃßõyOçøºñúOö0MBÒIgÆÞáÖAðßZÿÍS", @"ìQóÛR1yqòSìáÑîÀÎxJìhYúÌïêùwa", @"6GO6ÅÀc4aDÝX6joû1ÉÚ1úfuFB9ôÛuIøîhþZüÜBÐ93", @"LhCûAÀFõCßhNâBáýãEüìóüI7üÎÍeoÇàKX"},
 126                         new string [] {@"iLµÃPOØêµ7åtT4µBí8ÐüGäõEÝu5NáSÓíu9oöãexrkýMîËdü", @"äpÜkRmÝñrªnÄ4gãÖäì27LÄçÄßJámuuðénøH3", @"ÚIhÖbþmæVÏíØÇlÅµVçÂóµG2Ët2QëEúKÄøl1dBX9cVÃªpóT", @"7ÛbD1ÓUmJ"},
 127                         new string [] {@"Á7yÿ9eôðüxNDþÁÒoÌèE", @"ÌâñBTvÜIZØJÿOg3Åøc0ÌÇßÌÒªeõÐóÊúÃXeúÌDÄãpü", @"8xufMÍ5INÒFÿÙyYïnÖø2ÜçÉNúÕìßìu", @"jûNTPµhúgÞqèµÍQÜ", @"ÚRY4ïkägkùHøXDÌÝºõzá9bÏDÅXïÐÍ4ZgVS5î1Çs", @"LYòYíaBEhnGâÛçå", @"ÙHIÀþÀãG", @"KHÂáïzÞGÊqªÄ6Òf7óatþÿÙÊbxgÝoGLc", @"oóÓËqÑloÐâ3ZùÛÚfSÄÇn4ñðÛôÑQËÉpwOÁÅÓ2ä", @"b", @"37ZÄàüþLfyÙÆ3ÃøÁfÄØÑÿR9wÕæßèYqÓaêÛJNïg", @"fönîí9âsðÂÝÛO1FÀÃzyes09hÏÌóÜ6", @"jr9EÐàQßWëÅÜjs", @"QôyFÌYoÁig03lKNfOgTøcåÑiá2ÄGÍÒîãòÑsiÔñ", @"ÈþâWJ", @"XiULjBOªÈaqgwÆj7ïQk", @"ÉzaÞül7óKõØúëbã0INëhCÈþ", @"ÿfwúxqbÖMrñaËB1õpqÔåëíæ", @"ÅrÍxhIÂkVÆª9o5Ôÿ6ëÄ8À"},
 128                         new string [] {@"ÎÎY9È", @"BDiPäÿðrö6zQøÎPBm", @"ÃYºÆsíDæùÇåuZ0NÆ1îSÀìFiÄ", @"", @"IXûÁñvFWÜÐÙòiWùæøÒldJïvç4ÈVïÈùp", @"øËCÇXS", @"ïPRàÌûÃyFüåðÊwuwpÁHþ2o3lHùgÿâ6ØSûNÏªM3ËçÛpè7ÛùÚÚ", @"Oõ1w6N0é4êðMxtþô", @"3VÂåðqGOÈUúðcªFxYmeÏÚùÜÔ8ÁµuÎFBòÁöAªøóKWZöV", @"rbÌØÄçÒOõäøfxKÙðô8RsïYÇézÞüªyÄÂbâÌïù", @"dó1FøÍßEoûcAåÛÐ", @"yxèÕìzÕCÎãËãÈÎSdÍÆOßÐ3Ñ8îöZÅPªäpýokÀäòp5ÙMKþúªÙØR", @"ÚÀÞoe1TfV5Íê3írytÏÞÜéVsÔsSÀwÅeìFRòÿJñ3wOÄyïÏIeXÓ", @"eÅéµeJçdu3bÛBÇlùÃØjÛgôRÞ23jöÅÕÚIøë", @"gðoqç7µ", @"ouèVïFXey4û", @"rëÃÊQèÞÍÉÔxwªÿÙëJ8LÙZWÙìÓìúswòÅñVùý", @"LÒyÿØ7ÀºNÞçPÙbúfÜSíhcLóÙSsiýñÆJÁaï5Wn69ºA31eêÊø"},
 129                         new string [] {@"ïÛRøæY0CXùPÝÃòåÁeáìÒRºêy", @"nrln1", @"îënOÑOànM7ætÂY1ãgäIÕöÙEÌÅÆSvCNòeFpÿÛÜðDûexmPFÅëvc"},
 130                         new string [] {@"gÀÃhLbÓÕèíWÕXvBNÊâAÕlþ4ÈUQhîpìÕ", @"ôä7ÕË3ÿÒQÙËZDS", @"Iù1xMOlHèRîå", @"öÊVØVö9ÎÕfCUãñeHföDuxfõ6Ó8â4ÇõÙArhñöÈÕðÊF", @"GFïlÞÝjÚVhóØáBJ1ºxÑò1GÞÐ", @"êjnÞoÎPf6Çpû0", @"àñNÛðaTmcýßòÔgjÞNIÒÒeÄÓFªºÒYÂ3jÆìRÕLHÖØôØÊßÈ3", @"ÀôXõíæwßBlnÆ11vi2", @"SQþëªëyürZsúGgÂaëÄâÇÒ46UÉçúàVVÅçIìµèÌmÞ", @"þc1ÏùåñmQÝ8ÏMÅiqõídÇHÔÚëÿÂãmdÛm", @"ÙìR", @"7xóuÝëèbÂÊMÛ4LêÊÑjìÃ", @"þÓýöî2ïAðmÄÅkTªrgüVïiÔïXEûáHþõñóòJQ", @"Æ"},
 131                         new string [] {@"lyQYûoRÔUaqcODúîu8äÆZï4LôUÝrºPâéT2ÖåÀKÍõÙéJÞpæ", @"ÀÕpnóÀOÁªIg0QgOèÐL5îv8ÀfÙFNìW"},
 132                         new string [] {@"ÃnjoÍèËkuwYÝ7ç2csòçDûªÆGìö2m", @"ïgíÂuµ7ÕPJµBuéÑL97åoÒ7ÐTtPÎÊt1hñªÿËTRíëÿïîLÃÍFKCÇ", @"ÄÚÏÞlùÒlêtaßzÊäªAÇÛN", @"pRñQáQÎÃûL5ùÓX2µÁûDPoæÝwwHï", @"øuSTúÌ", @"ùëÿCrËoTDìöhìßEÚwúJ9ÒLWÅØÝnª", @"ÏjÁécæJã8ùûÏ", @"ÈË9ëèµpåÚAmB2VEUZàtøFzâÔíúx", @"ÍÌëXûõAøZVËÚMü2PWÝÌÇUÃëfùÁã", @"oKÈºgµKØºÖCyCË29Á7ÔùHÄiýÉêÝÇLJý6æªÌËæÝbku", @"EXµÚIªHúÀXKªÍdWIõÒLRíJÒôÊqÁ9ªñbþWßþx", @"Zpàø6ÆoæûÃu44tÛhdsnjÉeiDÖyóøªÑãÌ0Ø3üA1íãÌ", @"hÆåÅáúÅ", @"ðÒXR4Vd"},
 133                         new string [] {@"iIZm", @"ÝÂÄÃnîg"},
 134                         new string [] {@"éik2DQHØüwaÀÆÄ", @"uvÜõWDémÐfQíììåJBïüáõEøaëLáÿÁÏþÖòÑ", @"àêÂãµýÐgýâ", @"7º", @"jsýCkzaFAAÝGDmÛÿôåô6lìª8ê", @"µÎÙÎÊZAvýcóAyáYaý1ul9ÔDqZéÁÎm3µE", @"eadùjFLÑGèÜFoàYçÑaóÝÇDÄ2Iü0µTS4QñÀyuÝzÇÛOÃpvw24ä", @"ÑÆNAÑîQXïø", @"ácGQãC", @"3oîB7téCxÔõðð6ÝxäíLÒËu5jÊNgïL22Å"},
 135                         new string [] {}
 136                 };
 137                 static object [] state_methods_values = new object []  {
 138                         /*new object [] {
 139                                 "here goes name of method", new object [] {"arg1", 2, "etc", "must match type exactly"}
 140                                 },*/
 141                         new object [] {
 142                                 new object [] {"Add", new object [] {"a"}},
 143                                 new object [] {"Add", new object [] {'a'}},
 144                                 new object [] {"Add", new object [] {'a', 1, MS_System_ComponentModel.MaskedTextResultHint.Unknown}}
 145                                 },
 146                         new object [] {
 147                                 new object [] {"Add", new object [] {"a"}},
 148                                 new object [] {"Remove", new object [] {}},
 149                                 new object [] {"InsertAt", new object [] {'a', 1}}
 150                                 },
 151                         new object [] {
 152                                 new object [] {"Add", new object [] {"1"}},
 153                                 new object [] {"Add", new object [] {"2"}},
 154                                 new object [] {"InsertAt", new object [] {'3', 7}},
 155                                 new object [] {"InsertAt", new object [] {'4', 4}}
 156                                 },
 157                         new object [] {
 158                                 new object [] {"InsertAt", new object [] {'z', 0}},
 159                                 new object [] {"InsertAt", new object [] {'z', 1}},
 160                                 new object [] {"InsertAt", new object [] {'z', 2}},
 161                                 },
 162                         new object [] {
 163                                 new object [] {"InsertAt", new object [] {'z', 0}},
 164                                 new object [] {"InsertAt", new object [] {'z', 2}},
 165                                 }
 166                         };
 167                 /*static string state_methods = new string [] {
 168                         "Add",          // char, string, char+(out)int+(out)hint
 169                         "Clear",        // -, hint
 170                         "InsertAt",     // char+int, string+int, char+int+int+hint, string+int+int+hint
 171                         "Remove",       // -, int+hint
 172                         "RemoveAt",     // int, int+int, int+int+int+hint
 173                         "Replace",      // char+int, string+int, char+int+int+hint, string+int+int+hint, char+int+int+int+hint, string+int+int+int+hint
 174                         "Set"           // string, string+int+hint
 175                         };
 176                 */
 177                 //static public void char_gen ()
 178                 //{
 179                 //        string result = "";
 180                 //        Random rnd = new Random ();
 181                 //        result += "static char [][] add_char_test_values2 = new char [][] {" + Environment.NewLine;
 182                 //        for (int i = 0; i < 25; i++) {
 183                 //                result += "\tnew char [] {";
 184                 //                int b = rnd.Next (0, 20);
 185                 //                for (int j = 0; j < b; j++) {
 186                 //                        int a = rnd.Next (ushort.MinValue, ushort.MaxValue + 1);
 187                 //                        char c = Convert.ToChar (a);
 188                 //                        result += GetStringValue (c);
 189                 //                        if (j < b - 1)
 190                 //                                result += ", ";
 191                 //                        else
 192                 //                                result += "}";
 193                 //                }
 194                 //                if (i < 24)
 195                 //                        result += ", ";
 196                 //                else
 197                 //                        result += Environment.NewLine + "}";
 198                 //                result += Environment.NewLine;
 199                 //        }
 200                 //        MS_System.System.Diagnostics.Debug.WriteLine (result);
 201                 //}
 202                 //static public void str_gen ()
 203                 //{
 204                 //        string result = "";
 205                 //        Random rnd = new Random ();
 206                 //        result += "static string [][] add_string_test_values2 = new string [][] {" + Environment.NewLine;
 207                 //        for (int i = 0; i < 25; i++) {
 208                 //                result += "\tnew string [] {";
 209                 //                int b = rnd.Next (0, 20);
 210                 //                for (int j = 0; j < b; j++) {
 211                 //                        int c = rnd.Next (0, 50);
 212                 //                        string str = "";
 213                 //                        for (int k = 0; k < c; k++) {
 214                 //                                int a;
 215                 //                                if (i < 2) {
 216                 //                                        a = rnd.Next (ushort.MinValue, ushort.MaxValue + 1);
 217                 //                                } else if (i < 4) {
 218                 //                                        do {
 219                 //                                                a = rnd.Next (ushort.MinValue, 256);
 220                 //                                        } while (!MS_System_ComponentModel.MaskedTextProvider.IsValidInputChar (Convert.ToChar (a)));
 221                 //                                } else {
 222                 //                                        do {
 223                 //                                                a = rnd.Next (ushort.MinValue, 256);
 224                 //                                        } while (!char.IsLetterOrDigit (Convert.ToChar (a)));
 225                 //                                }
 226                 //                                str += Convert.ToChar (a).ToString ();
 227                 //                        }
 228                 //                        result += "@\"" + str.Replace ("\"", "\"\"") + "\"";
 229                 //                        if (j < b - 1)
 230                 //                                result += ", ";
 231                 //                        else
 232                 //                                result += "}";
 233                 //                }
 234                 //                if (b == 0)
 235                 //                        result += "}";
 236                 //                if (i < 24)
 237                 //                        result += ", ";
 238                 //                else
 239                 //                        result += Environment.NewLine + "};";
 240                 //                result += Environment.NewLine;
 241                 //        }
 242                 //        MS_System.System.Diagnostics.Debug.WriteLine (result);
 243                 //}
 244
 245                 static int Test ()
 246                 {
 247                         MaskedTextProviderTest tests = new MaskedTextProviderTest ();
 248                         tests.Replace_string_int_int_int_MaskedTextResultHintTest00137 ();
 249
 250                         return 0;
 251                 }
 252
 253                 static int Main (string [] args)
 254                 {
 255                         //return Test ();
 256
 257                         if (typeof (int).GetType ().Name != "RuntimeType") {
 258                                 Console.WriteLine ("This must be run on the MS runtime.");
 259                                 return 1;
 260                         }
 261
 262                         string file = "";
 263                         // Check that this path is correct before removing the comment.
 264                         // file = "..\\..\\Test\\System.ComponentModel\\MaskedTextProviderTestGenerated.cs";
 265                         // file = @"Z:\mono\head\mcs\class\System\Test\System.ComponentModel\MaskedTextProviderTestGenerated.cs";
 266
 267                         destination_file = file;
 268
 269                         if (destination_file == "") {
 270                                 Console.WriteLine ("You'll have to set the destination file. See source for instructions.");
 271                                 return 1;
 272                         }
 273
 274                         using (StreamWriter stream = new StreamWriter (new FileStream (file, FileMode.Create, FileAccess.Write), Encoding.Unicode)) {
 275                                 writer = stream;
 276                                 WriteFileHeader ();
 277
 278                                 GenerateAdd_char_int_MaskedTextResultHint_Test ();
 279                                 GenerateAdd_char_Test ();
 280                                 GenerateAdd_string_int_MaskedTextResultHint_Test ();
 281                                 GenerateAdd_string_Test ();
 282                                 GenerateClear_MaskedTextResultHint_Test ();
 283                                 GenerateClearTest ();
 284                                 GenerateCloneTest ();
 285                                 GenerateEditPositionsTest ();
 286                                 GenerateFindAssignedEditPositionFromTest ();
 287                                 GenerateFindAssignedEditPositionInRangeTest ();
 288                                 GenerateFindEditPositionFromTest ();
 289                                 GenerateFindEditPositionInRangeTest ();
 290                                 GenerateFindNonEditPositionFromTest ();
 291                                 GenerateFindNonEditPositionInRangeTest ();
 292                                 GenerateFindUnassignedEditPositionFromTest ();
 293                                 GenerateFindUnassignedEditPositionInRangeTest ();
 294                                 GenerateInsertAt_char_int_Test ();
 295                                 GenerateInsertAt_char_int_int_MaskedTextResultHintTest ();
 296                                 GenerateInsertAt_string_int_int_MaskedTextResultHintTest ();
 297                                 GenerateInsertAt_string_int_Test ();
 298                                 GenerateIsAvailablePositionTest ();
 299                                 GenerateIsEditPositionTest ();
 300                                 GenerateIsValidInputCharTest ();
 301                                 GenerateIsValidMaskCharTest ();
 302                                 GenerateIsValidPasswordCharTest ();
 303                                 GenerateItemTest ();
 304                                 GenerateRemoveTest ();
 305                                 GenerateRemove_int_MaskedTextResultHintTest ();
 306                                 GenerateRemoveAt_int_int_int_MaskedTextResultHintTest ();
 307                                 GenerateRemoveAt_int_int_Test ();
 308                                 GenerateRemoveAt_int_Test ();
 309                                 GenerateReplace_char_int_int_int_MaskedTextResultHintTest ();
 310                                 GenerateReplace_char_int_int_MaskedTextResultHintTest ();
 311                                 GenerateReplace_char_int_Test ();
 312                                 GenerateReplace_string_int_int_int_MaskedTextResultHintTest ();
 313                                 GenerateReplace_string_int_int_MaskedTextResultHintTest ();
 314                                 GenerateReplace_string_int_Test ();
 315                                 GenerateSet_string_int_MaskedTextResultHintTest ();
 316                                 GenerateSet_string_Test ();
 317                                 GenerateToDisplayStringTest ();
 318                                 GenerateToString_bool_bool_bool_int_int_Test ();
 319                                 GenerateToString_bool_bool_int_int_Test ();
 320                                 GenerateToString_bool_bool_Test ();
 321                                 GenerateToString_bool_int_int_Test ();
 322                                 GenerateToString_bool_Test ();
 323                                 GenerateToString_int_int_Test ();
 324                                 GenerateToStringTest ();
 325                                 GenerateVerifyCharTest ();
 326                                 GenerateVerifyEscapeCharTest ();
 327                                 GenerateVerifyString_string_int_MaskedTextResultHintTest ();
 328                                 GenerateVerifyString_string_Test ();
 329
 330                                 WriteFileFooter ();
 331                         }
 332
 333                         Console.WriteLine ("Press any key to exit.");
 334                         Console.Read ();
 335                         return 0;
 336                 }
 337
 338                 static void GenerateAdd_char_Test ()
 339                 {
 340                         string Name = "mtp";
 341                         string TestName = MethodInfo.GetCurrentMethod ().Name.Replace ("Generate", "");
 342                         int counter = 0;
 343
 344                         bool result;
 345                         MS_System_ComponentModel.MaskedTextProvider mtp = null;
 346
 347                         WriteTestHeader (TestName, "MaskedTextProvider mtp;", "int testPosition;", "MaskedTextResultHint resultHint;", "bool result;", "int Int32_out = 0;", "MaskedTextResultHint MaskedTextResultHint_out = MaskedTextResultHint.Unknown;");
 348
 349                         foreach (string mask in test_masks) {
 350                                 foreach (char [] chars in add_char_test_values) {
 351                                         foreach (char c in chars) {
 352                                                 bool more_states = true;
 353                                                 int stateindex = 0;
 354                                                 do {
 355
 356                                                         object [] arguments;
 357                                                         arguments = new object [] { c };
 358                                                         if (Compare ("Add", mask, ref stateindex, arguments, ref more_states)) {
 359                                                                 continue;
 360                                                         }
 361
 362                                                         WriteTestStart ();
 363                                                         mtp = new MS_System_ComponentModel.MaskedTextProvider (mask);
 364                                                         WriteLine ("mtp = new MaskedTextProvider (@\"" + mask.Replace ("\"", "\"\"") + "\");");
 365                                                         more_states = CreateState (mtp, stateindex);
 366                                                         stateindex++;
 367
 368                                                         result = mtp.Add (c);
 369                                                         WriteLine (string.Format ("result = mtp.Add ('\\x{0:X4}');", (int)c) + (c != char.MinValue ? "/* " + c.ToString () + " */" : "/* null */"));
 370                                                         WriteLine ("Assert.AreEqual ({0}, result, \"{1}#{2}\");", GetStringValue (result), TestName, (counter++).ToString ());
 371                                                         WriteAssertProperties (mtp, Name, TestName, ref counter);
 372                                                         WriteTestEnd ();
 373                                                 } while (more_states);
 374                                         }
 375                                 }
 376                         }
 377                         WriteTestFooter ();
 378                 }
 379                 static void GenerateAdd_char_int_MaskedTextResultHint_Test ()
 380                 {
 381                         string Name = "mtp";
 382                         string TestName = MethodInfo.GetCurrentMethod ().Name.Replace ("Generate", "");
 383                         int counter = 0;
 384
 385                         WriteTestHeader (TestName, "MaskedTextProvider mtp;", "int testPosition;", "MaskedTextResultHint resultHint;", "bool result;", "int Int32_out = 0;", "MaskedTextResultHint MaskedTextResultHint_out = MaskedTextResultHint.Unknown;");
 386
 387                         MS_System_ComponentModel.MaskedTextProvider mtp = null;
 388                         int testPosition = 0;
 389                         MS_System_ComponentModel.MaskedTextResultHint resultHint = MS_System_ComponentModel.MaskedTextResultHint.Unknown;
 390                         bool result;
 391
 392                         foreach (string mask in test_masks) {
 393                                 foreach (char [] chars in add_char_test_values) {
 394                                         foreach (char c in chars) {
 395                                                 bool more_states = true;
 396                                                 int stateindex = 0;
 397                                                 do {
 398
 399                                                         object [] arguments;
 400                                                         arguments = new object [] { c, testPosition, resultHint };
 401                                                         if (Compare ("Add", mask, ref stateindex, arguments, ref more_states)) {
 402                                                                 continue;
 403                                                         }
 404
 405                                                         WriteTestStart ();
 406                                                         mtp = new MS_System_ComponentModel.MaskedTextProvider (mask);
 407                                                         WriteLine ("mtp = new MaskedTextProvider (@\"" + mask.Replace ("\"", "\"\"") + "\");");
 408
 409                                                         more_states = CreateState (mtp, stateindex);
 410                                                         stateindex++;
 411
 412                                                         result = mtp.Add (c, out testPosition, out resultHint);
 413                                                         WriteLine (string.Format ("result = mtp.Add ('\\x{0:X4}', out testPosition, out resultHint);", (int)c) + (c != char.MinValue ? "/* " + c.ToString () + " */" : "/* null */"));
 414                                                         WriteLine ("Assert.AreEqual ({0}, result, \"{1}#{2}\");", GetStringValue (result), TestName, (counter++).ToString ());
 415                                                         WriteLine ("Assert.AreEqual ({0}, resultHint, \"{1}#{2}\");", GetStringValue (resultHint), TestName, (counter++).ToString ());
 416                                                         WriteLine ("Assert.AreEqual ({0}, testPosition, \"{1}#{2}\");", GetStringValue (testPosition), TestName, (counter++).ToString ());
 417                                                         WriteAssertProperties (mtp, Name, TestName, ref counter);
 418
 419                                                         WriteTestEnd ();
 420                                                 } while (more_states);
 421                                         }
 422                                 }
 423                         }
 424                         WriteTestFooter ();
 425                 }
 426                 static void GenerateAdd_string_Test ()
 427                 {
 428                         string Name = "mtp";
 429                         string TestName = MethodInfo.GetCurrentMethod ().Name.Replace ("Generate", "");
 430                         int counter = 0;
 431
 432                         WriteTestHeader (TestName, "MaskedTextProvider mtp;", "int testPosition;", "MaskedTextResultHint resultHint;", "bool result;", "int Int32_out = 0;", "MaskedTextResultHint MaskedTextResultHint_out = MaskedTextResultHint.Unknown;");
 433
 434                         MS_System_ComponentModel.MaskedTextProvider mtp = null;
 435                         bool result;
 436
 437                         foreach (string mask in test_masks) {
 438                                 foreach (string [] strings in add_string_test_values) {
 439                                         foreach (string s in strings) {
 440                                                 bool more_states = true;
 441                                                 int stateindex = 0;
 442                                                 do {
 443
 444                                                         object [] arguments;
 445                                                         arguments = new object [] { s };
 446                                                         if (Compare ("Add", mask, ref stateindex, arguments, ref more_states)) {
 447                                                                 continue;
 448                                                         }
 449
 450                                                         WriteTestStart ();
 451                                                         mtp = new MS_System_ComponentModel.MaskedTextProvider (mask);
 452                                                         WriteLine ("mtp = new MaskedTextProvider (@\"" + mask.Replace ("\"", "\"\"") + "\");");
 453                                                         more_states = CreateState (mtp, stateindex);
 454                                                         stateindex++;
 455                                                         result = mtp.Add (s);
 456                                                         WriteLineNonFormat ("result = mtp.Add (@\"" + s.Replace ("\"", "\"\"") + "\");");
 457                                                         WriteLine ("Assert.AreEqual ({0}, result, \"{1}#{2}\");", GetStringValue (result), TestName, (counter++).ToString ());
 458                                                         WriteAssertProperties (mtp, Name, TestName, ref counter);
 459                                                         WriteTestEnd ();
 460                                                 } while (more_states);
 461                                         }
 462                                 }
 463                         }
 464                         WriteTestFooter ();
 465                 }
 466                 static void GenerateAdd_string_int_MaskedTextResultHint_Test ()
 467                 {
 468                         string Name = "mtp";
 469                         string TestName = MethodInfo.GetCurrentMethod ().Name.Replace ("Generate", "");
 470                         int counter = 0;
 471
 472                         WriteTestHeader (TestName, "MaskedTextProvider mtp;", "int testPosition;", "MaskedTextResultHint resultHint;", "bool result;", "int Int32_out = 0;", "MaskedTextResultHint MaskedTextResultHint_out = MaskedTextResultHint.Unknown;");
 473
 474                         MS_System_ComponentModel.MaskedTextProvider mtp = null;
 475                         int testPosition = 0;
 476                         MS_System_ComponentModel.MaskedTextResultHint resultHint = MS_System_ComponentModel.MaskedTextResultHint.Unknown;
 477
 478                         bool result;
 479
 480                         foreach (string mask in test_masks) {
 481                                 foreach (string [] strings in add_string_test_values) {
 482                                         foreach (string s in strings) {
 483                                                 bool more_states = true;
 484                                                 int stateindex = 0;
 485                                                 do {
 486
 487                                                         object [] arguments;
 488                                                         arguments = new object [] { s, testPosition, resultHint };
 489                                                         if (Compare ("Add", mask, ref stateindex, arguments, ref more_states)) {
 490                                                                 continue;
 491                                                         }
 492                                                         WriteTestStart ();
 493                                                         mtp = new MS_System_ComponentModel.MaskedTextProvider (mask);
 494                                                         WriteLine ("mtp = new MaskedTextProvider (@\"" + mask.Replace ("\"", "\"\"") + "\");");
 495                                                         more_states = CreateState (mtp, stateindex);
 496                                                         stateindex++;
 497
 498                                                         result = mtp.Add (s, out testPosition, out resultHint);
 499                                                         WriteLineNonFormat ("result = mtp.Add (@\"" + s.Replace ("\"", "\"\"") + "\", out testPosition, out resultHint);");
 500                                                         WriteLine ("Assert.AreEqual ({0}, result, \"{1}#{2}\");", GetStringValue (result), TestName, (counter++).ToString ());
 501                                                         WriteLine ("Assert.AreEqual ({0}, resultHint, \"{1}#{2}\");", GetStringValue (resultHint), TestName, (counter++).ToString ());
 502                                                         WriteLine ("Assert.AreEqual ({0}, testPosition, \"{1}#{2}\");", GetStringValue (testPosition), TestName, (counter++).ToString ());
 503                                                         WriteAssertProperties (mtp, Name, TestName, ref counter);
 504                                                         WriteLine ("");
 505                                                         WriteTestEnd ();
 506                                                 } while (more_states);
 507                                         }
 508                                 }
 509                         }
 510                         WriteTestFooter ();
 511                 }
 512
 513                 static void GenerateClearTest ()
 514                 {
 515                         GenerateClear_MaskedTextResultHint_Test (false);
 516                 }
 517                 static void GenerateClear_MaskedTextResultHint_Test ()
 518                 {
 519                         GenerateClear_MaskedTextResultHint_Test (true);
 520                 }
 521
 522                 static void GenerateClear_MaskedTextResultHint_Test (bool with_result)
 523                 {
 524                         string Name = "mtp";
 525                         string TestName = MethodInfo.GetCurrentMethod ().Name.Replace ("Generate", "");
 526                         int counter = 0;
 527
 528                         if (!with_result) {
 529                                 TestName = TestName.Replace ("_MaskedTextResultHint_", "");
 530                         }
 531
 532                         WriteTestHeader (TestName, "MaskedTextProvider mtp;", "int testPosition;", "MaskedTextResultHint resultHint;", "bool result;", "int Int32_out = 0;", "MaskedTextResultHint MaskedTextResultHint_out = MaskedTextResultHint.Unknown;");
 533
 534                         MS_System_ComponentModel.MaskedTextProvider mtp = null;
 535                         MS_System_ComponentModel.MaskedTextResultHint resultHint = MS_System_ComponentModel.MaskedTextResultHint.Unknown;
 536
 537                         foreach (string mask in test_masks) {
 538                                 bool more_states = true;
 539                                 int stateindex = 0;
 540                                 do {
 541
 542                                         object [] arguments;
 543                                         arguments = new object [] { resultHint };
 544                                         if (Compare ("Clear", mask, ref stateindex, arguments, ref more_states)) {
 545                                                 continue;
 546                                         }
 547
 548                                         WriteTestStart ();
 549                                         mtp = new MS_System_ComponentModel.MaskedTextProvider (mask);
 550                                         WriteLine ("mtp = new MaskedTextProvider (@\"" + mask.Replace ("\"", "\"\"") + "\");");
 551                                         more_states = CreateState (mtp, stateindex);
 552                                         stateindex++;
 553
 554                                         if (with_result) {
 555                                                 mtp.Clear (out resultHint);
 556                                                 WriteLine ("mtp.Clear (out resultHint);");
 557                                                 WriteLine ("Assert.AreEqual ({0}, resultHint, \"{1}#{2}\");", GetStringValue (resultHint), TestName, (counter++).ToString ());
 558                                         } else {
 559                                                 mtp.Clear ();
 560                                                 WriteLine ("mtp.Clear ();");
 561                                         }
 562                                         WriteAssertProperties (mtp, Name, TestName, ref counter);
 563                                         WriteTestEnd ();
 564                                 } while (more_states);
 565                         }
 566                         WriteTestFooter ();
 567                 }
 568                 static void GenerateCloneTest ()
 569                 {
 570                         ////string Name = "mtp";
 571                         //string TestName = MethodInfo.GetCurrentMethod ().Name.Replace ("Generate", "");
 572                         ////int counter = 0;
 573
 574
 575                         //WriteTestHeader (TestName);
 576                         //WriteLine ("");
 577                         //WriteTestStart ();
 578                         //WriteLine ("Assert.Ignore (\"Only manual tests here for the moment.\");");
 579                         //WriteTestEnd ();
 580                         //WriteTestFooter ();
 581                 }
 582
 583                 static void GenerateEditPositionsTest ()
 584                 {
 585                         int counter = 0;
 586                         MS_System_ComponentModel.MaskedTextProvider mtp = null;
 587                         string TestName = "EditPositionsTestGenerated";
 588
 589                         WriteTestHeader (TestName, "MaskedTextProvider mtp;", "int testPosition;", "MaskedTextResultHint resultHint;", "bool result;", "int Int32_out = 0;", "MaskedTextResultHint MaskedTextResultHint_out = MaskedTextResultHint.Unknown;");
 590                         WriteLine ("");
 591                         foreach (string mask in test_masks) {
 592                                 int stateindex = 0;
 593                                 bool more_states = true;
 594                                 do {
 595                                         object [] arguments;
 596                                         arguments = new object [] {};
 597                                         if (Compare ("EditPositions", mask, ref stateindex, arguments, ref more_states)) {
 598                                                 continue;
 599                                         }
 600
 601                                         WriteTestStart ();
 602
 603                                         string new_statement = "mtp = new MaskedTextProvider (@\"" + mask.Replace ("\"", "\"\"") + "\");";
 604                                         more_states = CreateState (mtp, stateindex);
 605                                         stateindex++;
 606                                         mtp = new MS_System_ComponentModel.MaskedTextProvider (mask);
 607                                         string result = MaskedTextProviderTest.join (mtp.EditPositions, ";");
 608                                         WriteLine ("");
 609                                         WriteLine (new_statement);
 610                                         WriteLine ("Assert.AreEqual (\"" + result + "\", MaskedTextProviderTest.join (mtp.EditPositions, \";\"), \"{0}#{1}\");", TestName, (counter++).ToString ());
 611                                         WriteTestEnd ();
 612                                 } while (more_states);
 613                         }
 614
 615                         WriteTestFooter ();
 616
 617                 }
 618
 619                 static void GenerateFindFromTest (string methodName)
 620                 {
 621                         string Name = "mtp";
 622                         string TestName = methodName + "Test";
 623                         int counter = 0;
 624
 625                         WriteTestHeader (TestName, "MaskedTextProvider mtp;", "int Int32_out = 0;", "MaskedTextResultHint MaskedTextResultHint_out = MaskedTextResultHint.Unknown;");
 626                         MS_System_ComponentModel.MaskedTextProvider mtp = null;
 627
 628                         foreach (string mask in test_masks) {
 629                                 foreach (bool value in new bool [] { true, false }) {
 630                                         for (int i = 0; i < mask.Length + 2; i++) {
 631                                                 int stateindex = 0;
 632                                                 bool more_states = true;
 633                                                 do {
 634                                                         object [] arguments;
 635                                                         arguments = new object [] { i, value };
 636                                                         if (Compare (methodName, mask, ref stateindex, arguments, ref more_states)) {
 637                                                                 continue;
 638                                                         }
 639
 640                                                         WriteTestStart ();
 641                                                         mtp = new MS_System_ComponentModel.MaskedTextProvider (mask);
 642                                                         WriteLine ("mtp = new MaskedTextProvider (@\"" + mask.Replace ("\"", "\"\"") + "\");");
 643                                                         more_states = CreateState (mtp, stateindex);
 644                                                         stateindex++;
 645
 646                                                         WriteLine ("Assert.AreEqual ({0}, mtp." + methodName + "({1}, {3}), \"#{2}\");", mtp.GetType ().InvokeMember (methodName, BindingFlags.Public | BindingFlags.Instance | BindingFlags.InvokeMethod, null, mtp.GetType (), arguments).ToString (), i.ToString (), (counter++).ToString (), value ? "true" : "false");
 647
 648                                                         WriteAssertProperties (mtp, Name, TestName, ref counter);
 649                                                         WriteTestEnd ();
 650
 651                                                 } while (more_states);
 652                                         }
 653                                 }
 654                         }
 655                         WriteTestFooter ();
 656                 }
 657                 static void GenerateFindRangeTest (string methodName)
 658                 {
 659                         string Name = "mtp";
 660                         string TestName = methodName + "Test";
 661                         int counter = 0;
 662
 663                         WriteTestHeader (TestName, "MaskedTextProvider mtp;", "int Int32_out = 0;", "MaskedTextResultHint MaskedTextResultHint_out = MaskedTextResultHint.Unknown;");
 664                         MS_System_ComponentModel.MaskedTextProvider mtp = null;
 665
 666                         foreach (string mask in test_masks) {
 667                                 foreach (bool value in new bool [] { true, false }) {
 668                                         for (int i = 0; i < mask.Length + 2; i++) {
 669                                                 for (int k = 0; k < mask.Length + 2; k++) {
 670
 671                                                         int stateindex = 0;
 672                                                         bool more_states = true;
 673                                                         do {
 674
 675                                                                 object [] arguments;
 676                                                                 arguments = new object [] { i, k, value };
 677                                                                 if (Compare (methodName, mask, ref stateindex, arguments, ref more_states)) {
 678                                                                         continue;
 679                                                                 }
 680
 681                                                                 WriteTestStart ();
 682                                                                 mtp = new MS_System_ComponentModel.MaskedTextProvider (mask);
 683                                                                 WriteLine ("mtp = new MaskedTextProvider (@\"" + mask.Replace ("\"", "\"\"") + "\");");
 684                                                                 more_states = CreateState (mtp, stateindex);
 685                                                                 stateindex++;
 686
 687                                                                 WriteLine ("Assert.AreEqual ({0}, mtp." + methodName + " ({1}, {2}, {4}), \"#{3}\");", mtp.GetType ().InvokeMember (methodName, BindingFlags.Public | BindingFlags.Instance | BindingFlags.InvokeMethod, null, mtp.GetType (), arguments).ToString (), i.ToString (), k.ToString (), (counter++).ToString (), value ? "true" : "false");
 688
 689                                                                 WriteAssertProperties (mtp, Name, TestName, ref counter);
 690                                                                 WriteTestEnd ();
 691
 692                                                         } while (more_states);
 693                                                 }
 694                                         }
 695                                 }
 696                         }
 697
 698                         WriteTestFooter ();
 699                 }
 700                 static void GenerateFindAssignedEditPositionFromTest ()
 701                 {
 702                         GenerateFindFromTest ("FindAssignedEditPositionFrom");
 703                 }
 704                 static void GenerateFindAssignedEditPositionInRangeTest ()
 705                 {
 706                         GenerateFindRangeTest ("FindAssignedEditPositionInRange");
 707                 }
 708                 static void GenerateFindEditPositionFromTest ()
 709                 {
 710                         GenerateFindFromTest ("FindEditPositionFrom");
 711                 }
 712                 static void GenerateFindEditPositionInRangeTest ()
 713                 {
 714                         GenerateFindRangeTest ("FindEditPositionInRange");
 715                 }
 716                 static void GenerateFindNonEditPositionFromTest ()
 717                 {
 718                         GenerateFindFromTest ("FindNonEditPositionFrom");
 719                 }
 720                 static void GenerateFindNonEditPositionInRangeTest ()
 721                 {
 722                         GenerateFindRangeTest ("FindNonEditPositionInRange");
 723                 }
 724                 static void GenerateFindUnassignedEditPositionFromTest ()
 725                 {
 726                         GenerateFindFromTest ("FindUnassignedEditPositionFrom");
 727                 }
 728                 static void GenerateFindUnassignedEditPositionInRangeTest ()
 729                 {
 730                         GenerateFindRangeTest ("FindUnassignedEditPositionInRange");
 731                 }
 732
 733                 static void GenerateInsertAt_char_int_Test ()
 734                 {
 735                         string Name = "mtp";
 736                         string TestName = MethodInfo.GetCurrentMethod ().Name.Replace ("Generate", "");
 737                         int counter = 0;
 738
 739                         WriteTestHeader (TestName, "MaskedTextProvider mtp;", "int Int32_out = 0;", "MaskedTextResultHint MaskedTextResultHint_out = MaskedTextResultHint.Unknown;");
 740                         MS_System_ComponentModel.MaskedTextProvider mtp = null;
 741
 742                         foreach (string mask in test_masks) {
 743                                 foreach (char chr in char_values) {
 744                                         for (int i = 0; i < mask.Length; i++) {
 745                                                 bool more_states = true;
 746                                                 int stateindex = 0;
 747                                                 do {
 748
 749                                                         object [] arguments;
 750                                                         arguments = new object [] { chr, i };
 751                                                         if (Compare ("InsertAt", mask, ref stateindex, arguments, ref more_states)) {
 752                                                                 continue;
 753                                                         }
 754
 755                                                         WriteTestStart ();
 756                                                         mtp = new MS_System_ComponentModel.MaskedTextProvider (mask);
 757                                                         WriteLine ("mtp = new MaskedTextProvider (@\"" + mask.Replace ("\"", "\"\"") + "\");");
 758                                                         more_states = CreateState (mtp, stateindex);
 759                                                         stateindex++;
 760
 761                                                         WriteLine ("Assert.AreEqual ({0}, mtp.InsertAt ({1}, {2}), \"#{3}\");", GetStringValue (mtp.InsertAt (chr, i)), GetStringValue (chr), i.ToString (), (counter++).ToString ());
 762
 763                                                         WriteAssertProperties (mtp, Name, TestName, ref counter);
 764                                                         WriteTestEnd ();
 765
 766                                                 } while (more_states);
 767                                         }
 768                                 }
 769                         }
 770
 771                         WriteTestFooter ();
 772                 }
 773                 static void GenerateInsertAt_string_int_Test ()
 774                 {
 775                         string Name = "mtp";
 776                         string TestName = MethodInfo.GetCurrentMethod ().Name.Replace ("Generate", "");
 777                         int counter = 0;
 778
 779                         WriteTestHeader (TestName, "MaskedTextProvider mtp;", "int Int32_out = 0;", "MaskedTextResultHint MaskedTextResultHint_out = MaskedTextResultHint.Unknown;");
 780                         MS_System_ComponentModel.MaskedTextProvider mtp = null;
 781
 782                         foreach (string mask in test_masks) {
 783                                 foreach (string str in string_values) {
 784                                         if (str == null)
 785                                                 continue;
 786
 787                                         for (int i = 0; i < mask.Length; i++) {
 788                                                 bool more_states = true;
 789                                                 int stateindex = 0;
 790                                                 do {
 791
 792                                                         object [] arguments;
 793                                                         arguments = new object [] { str, i };
 794                                                         if (Compare ("InsertAt", mask, ref stateindex, arguments, ref more_states)) {
 795                                                                 continue;
 796                                                         }
 797
 798                                                         WriteTestStart ();
 799                                                         mtp = new MS_System_ComponentModel.MaskedTextProvider (mask);
 800                                                         WriteLine ("mtp = new MaskedTextProvider (@\"" + mask.Replace ("\"", "\"\"") + "\");");
 801                                                         more_states = CreateState (mtp, stateindex);
 802                                                         stateindex++;
 803
 804                                                         WriteLine ("Assert.AreEqual ({0}, mtp.InsertAt ({1}, {2}), \"#{3}\");", GetStringValue (mtp.InsertAt (str, i)), GetStringValue (str), i.ToString (), (counter++).ToString ());
 805
 806                                                         WriteAssertProperties (mtp, Name, TestName, ref counter);
 807                                                         WriteTestEnd ();
 808
 809                                                 } while (more_states);
 810                                         }
 811                                 }
 812                         }
 813
 814                         WriteTestFooter ();
 815                 }
 816                 static void GenerateInsertAt_char_int_int_MaskedTextResultHintTest ()
 817                 {
 818                         string Name = "mtp";
 819                         string TestName = MethodInfo.GetCurrentMethod ().Name.Replace ("Generate", "");
 820                         int counter = 0;
 821
 822                         WriteTestHeader (TestName, "MaskedTextProvider mtp;", "int Int32_out = 0;", "MaskedTextResultHint MaskedTextResultHint_out = MaskedTextResultHint.Unknown;");
 823                         MS_System_ComponentModel.MaskedTextProvider mtp = null;
 824                         int Int32_out = 0;
 825                         MS_System_ComponentModel.MaskedTextResultHint MaskedTextResultHint_out = MS_System_ComponentModel.MaskedTextResultHint.Unknown;
 826
 827                         foreach (string mask in test_masks) {
 828                                 foreach (char chr in char_values) {
 829                                         for (int i = 0; i < mask.Length; i++) {
 830                                                 bool more_states = true;
 831                                                 int stateindex = 0;
 832                                                 do {
 833
 834                                                         object [] arguments;
 835                                                         arguments = new object [] { chr, i, Int32_out, MaskedTextResultHint_out };
 836                                                         if (Compare ("InsertAt", mask, ref stateindex, arguments, ref more_states)) {
 837                                                                 continue;
 838                                                         }
 839
 840                                                         WriteTestStart ();
 841                                                         mtp = new MS_System_ComponentModel.MaskedTextProvider (mask);
 842                                                         WriteLine ("mtp = new MaskedTextProvider (@\"" + mask.Replace ("\"", "\"\"") + "\");");
 843                                                         more_states = CreateState (mtp, stateindex);
 844                                                         stateindex++;
 845                                                         WriteLine ("Assert.AreEqual ({0}, mtp.InsertAt ({1}, {2}, out Int32_out, out MaskedTextResultHint_out), \"#{3}\");",
 846                                                                 GetStringValue (mtp.InsertAt (chr, i, out Int32_out, out MaskedTextResultHint_out)), GetStringValue (chr), i.ToString (), (counter++).ToString ());
 847                                                         WriteLine ("Assert.AreEqual ({0}, Int32_out, \"#{1}\");", GetStringValue (Int32_out), (counter++).ToString ());
 848                                                         WriteLine ("Assert.AreEqual ({0}, MaskedTextResultHint_out, \"#{1}\");", GetStringValue (MaskedTextResultHint_out), (counter++).ToString ());
 849
 850                                                         WriteAssertProperties (mtp, Name, TestName, ref counter);
 851                                                         WriteTestEnd ();
 852
 853                                                 } while (more_states);
 854                                         }
 855                                 }
 856                         }
 857
 858                         WriteTestFooter ();
 859                 }
 860                 static void GenerateInsertAt_string_int_int_MaskedTextResultHintTest ()
 861                 {
 862                         string Name = "mtp";
 863                         string TestName = MethodInfo.GetCurrentMethod ().Name.Replace ("Generate", "");
 864                         int counter = 0;
 865
 866                         WriteTestHeader (TestName, "MaskedTextProvider mtp;", "int Int32_out = 0;", "MaskedTextResultHint MaskedTextResultHint_out = MaskedTextResultHint.Unknown;");
 867                         MS_System_ComponentModel.MaskedTextProvider mtp = null;
 868                         int Int32_out = 0;
 869                         MS_System_ComponentModel.MaskedTextResultHint MaskedTextResultHint_out = MS_System_ComponentModel.MaskedTextResultHint.Unknown;
 870
 871                         foreach (string mask in test_masks) {
 872
 873                                 foreach (string str in string_values) {
 874                                         if (str == null)
 875                                                 continue;
 876
 877                                         for (int i = 0; i < mask.Length; i++) {
 878                                                 bool more_states = true;
 879                                                 int stateindex = 0;
 880                                                 do {
 881
 882                                                         object [] arguments;
 883                                                         arguments = new object [] { str, i, Int32_out, MaskedTextResultHint_out };
 884                                                         if (Compare ("InsertAt", mask, ref stateindex, arguments, ref more_states)) {
 885                                                                 continue;
 886                                                         }
 887
 888                                                         WriteTestStart ();
 889                                                         mtp = new MS_System_ComponentModel.MaskedTextProvider (mask);
 890                                                         WriteLine ("mtp = new MaskedTextProvider (@\"" + mask.Replace ("\"", "\"\"") + "\");");
 891                                                         more_states = CreateState (mtp, stateindex);
 892                                                         stateindex++;
 893
 894                                                         WriteLine ("Assert.AreEqual ({0}, mtp.InsertAt ({1}, {2}, out Int32_out, out MaskedTextResultHint_out), \"#{3}\");",
 895                                                                 GetStringValue (mtp.InsertAt (str, i, out Int32_out, out MaskedTextResultHint_out)), GetStringValue (str), i.ToString (), (counter++).ToString ());
 896                                                         WriteLine ("Assert.AreEqual ({0}, Int32_out, \"#{1}\");", GetStringValue (Int32_out), (counter++).ToString ());
 897                                                         WriteLine ("Assert.AreEqual ({0}, MaskedTextResultHint_out, \"#{1}\");", GetStringValue (MaskedTextResultHint_out), (counter++).ToString ());
 898
 899                                                         WriteAssertProperties (mtp, Name, TestName, ref counter);
 900                                                         WriteTestEnd ();
 901
 902                                                 } while (more_states);
 903                                         }
 904                                 }
 905                         }
 906
 907                         WriteTestFooter ();
 908                 }
 909                 static void GenerateIsAvailablePositionTest ()
 910                 {
 911                         string Name = "mtp";
 912                         string TestName = MethodInfo.GetCurrentMethod ().Name.Replace ("Generate", "");
 913                         int counter = 0;
 914
 915                         WriteTestHeader (TestName, "MaskedTextProvider mtp;", "int Int32_out = 0;", "MaskedTextResultHint MaskedTextResultHint_out = MaskedTextResultHint.Unknown;");
 916                         MS_System_ComponentModel.MaskedTextProvider mtp = null;
 917                         //int Int32_out = 0;
 918                         //MS_System_ComponentModel.MaskedTextResultHint MaskedTextResultHint_out = MS_System_ComponentModel.MaskedTextResultHint.Unknown;
 919
 920                         foreach (string mask in test_masks) {
 921                                 for (int i = -1; i < mask.Length + 2; i++) {
 922                                         bool more_states = true;
 923                                         int stateindex = 0;
 924                                         do {
 925                                                 object [] arguments;
 926                                                 arguments = new object [] { i };
 927                                                 if (Compare ("IsAvailablePosition", mask, ref stateindex, arguments, ref more_states)) {
 928                                                         continue;
 929                                                 }
 930
 931                                                 WriteTestStart ();
 932                                                 mtp = new MS_System_ComponentModel.MaskedTextProvider (mask);
 933                                                 WriteLine ("mtp = new MaskedTextProvider (@\"" + mask.Replace ("\"", "\"\"") + "\");");
 934                                                 more_states = CreateState (mtp, stateindex);
 935                                                 stateindex++;
 936
 937                                                 WriteLine ("Assert.AreEqual ({0}, mtp.IsAvailablePosition ({1}), \"#{2}\");", GetStringValue (mtp.IsAvailablePosition (i)), i.ToString (), (counter++).ToString ());
 938
 939                                                 WriteAssertProperties (mtp, Name, TestName, ref counter);
 940                                                 WriteTestEnd ();
 941
 942                                         } while (more_states);
 943                                 }
 944                         }
 945
 946                         WriteTestFooter ();
 947                 }
 948                 static void GenerateIsEditPositionTest ()
 949                 {
 950                         string Name = "mtp";
 951                         string TestName = MethodInfo.GetCurrentMethod ().Name.Replace ("Generate", "");
 952                         int counter = 0;
 953
 954
 955                         WriteTestHeader (TestName, "MaskedTextProvider mtp;", "int Int32_out = 0;", "MaskedTextResultHint MaskedTextResultHint_out = MaskedTextResultHint.Unknown;");
 956                         MS_System_ComponentModel.MaskedTextProvider mtp = null;
 957                         //int Int32_out = 0;
 958                         //MS_System_ComponentModel.MaskedTextResultHint MaskedTextResultHint_out = MS_System_ComponentModel.MaskedTextResultHint.Unknown;
 959
 960                         foreach (string mask in test_masks) {
 961                                 for (int i = -1; i < mask.Length + 2; i++) {
 962                                         bool more_states = true;
 963                                         int stateindex = 0;
 964                                         do {
 965                                                 object [] arguments;
 966                                                 arguments = new object [] { i };
 967                                                 if (Compare ("IsEditPosition", mask, ref stateindex, arguments, ref more_states)) {
 968                                                         continue;
 969                                                 }
 970
 971                                                 WriteTestStart ();
 972                                                 mtp = new MS_System_ComponentModel.MaskedTextProvider (mask);
 973                                                 WriteLine ("mtp = new MaskedTextProvider (@\"" + mask.Replace ("\"", "\"\"") + "\");");
 974                                                 more_states = CreateState (mtp, stateindex);
 975                                                 stateindex++;
 976
 977                                                 WriteLine ("Assert.AreEqual ({0}, mtp.IsEditPosition ({1}), \"#{2}\");", GetStringValue (mtp.IsEditPosition (i)), i.ToString (), (counter++).ToString ());
 978
 979                                                 WriteAssertProperties (mtp, Name, TestName, ref counter);
 980                                                 WriteTestEnd ();
 981
 982                                         } while (more_states);
 983                                 }
 984                         }
 985
 986                         WriteTestFooter ();
 987                 }
 988                 static void GenerateIsValidInputCharTest ()
 989                 {
 990                         string TestName = "IsValidInputCharTestGenerated";
 991
 992                         dont_write = true;
 993 doagain:
 994                         WriteTestHeader (TestName);
 995                         WriteTestStart ();
 996
 997                         int max = (int)char.MaxValue;
 998                         BitArray bits = new BitArray (max);
 999                         for (int i = 0; i < max; i++) {
1000                                 bool result_MS = MS_System_ComponentModel.MaskedTextProvider.IsValidInputChar ((char)i);
1001                                 bool result_Mono = MaskedTextProvider.IsValidInputChar ((char) i);
1002                                 if (dont_write && result_MS != result_Mono) {
1003                                         dont_write = false;
1004                                         goto doagain;
1005                                 }
1006                                 bits.Set (i, result_MS);
1007
1008                         }
1009                         StringBuilder bit_array = new StringBuilder ();
1010                         bit_array.AppendLine ("int [] answers;");
1011                         bit_array.AppendLine (tabs + "unchecked {");
1012                         bit_array.Append (tabs + "answers = new int [] {");
1013                         int [] numbers = new int [max / 32 + 1];
1014                         bits.CopyTo (numbers, 0);
1015                         for (int i = 0; i < numbers.Length; i++) {
1016                                 if (i % 8 == 0) {
1017                                         bit_array.AppendLine ("");
1018                                         bit_array.Append (tabs + "\t");
1019                                 }
1020                                 bit_array.Append (String.Format ("(int) 0x{0:X8}", numbers [i]));
1021                                 if (i != numbers.Length - 1)
1022                                         bit_array.Append (", ");
1023
1024                         }
1025                         bit_array.AppendLine ("");
1026                         bit_array.AppendLine (tabs + "};");
1027                         bit_array.AppendLine (tabs + "};");
1028                         WriteLineNonFormat (bit_array.ToString ());
1029                         WriteLine ("BitArray bits = new BitArray (answers);");
1030                         WriteLine ("for (int i = 0; i < (int) char.MaxValue; i++)");
1031                         WriteLine ("\tAssert.AreEqual (bits.Get (i), MaskedTextProvider.IsValidInputChar ((char) i), \"{0}#\" + i.ToString ());", TestName);
1032
1033                         WriteTestEnd ();
1034                         WriteTestFooter ();
1035                 }
1036                 static void GenerateIsValidMaskCharTest ()
1037                 {
1038                         string TestName = "IsValidMaskCharTestGenerated";
1039
1040                         dont_write = true;
1041                 doagain:
1042
1043                         WriteTestHeader (TestName);
1044                         WriteTestStart ();
1045
1046                         int max = (int)char.MaxValue;
1047                         BitArray bits = new BitArray (max);
1048                         for (int i = 0; i < max; i++) {
1049                                 bool result_MS = MS_System_ComponentModel.MaskedTextProvider.IsValidMaskChar ((char)i);
1050                                 bool result_Mono = MaskedTextProvider.IsValidMaskChar ((char)i);
1051                                 if (dont_write && result_MS != result_Mono) {
1052                                         dont_write = false;
1053                                         goto doagain;
1054                                 }
1055                                 bits.Set (i, result_MS);
1056                         }
1057                         StringBuilder bit_array = new StringBuilder ();
1058                         bit_array.AppendLine ("int [] answers;");
1059                         bit_array.AppendLine (tabs + "unchecked {");
1060                         bit_array.Append (tabs + "answers = new int [] {");
1061                         int [] numbers = new int [max / 32 + 1];
1062                         bits.CopyTo (numbers, 0);
1063                         for (int i = 0; i < numbers.Length; i++) {
1064                                 if (i % 8 == 0) {
1065                                         bit_array.AppendLine ("");
1066                                         bit_array.Append (tabs + "\t");
1067                                 }
1068                                 bit_array.Append (String.Format ("(int) 0x{0:X8}", numbers [i]));
1069                                 if (i != numbers.Length - 1)
1070                                         bit_array.Append (", ");
1071
1072                         }
1073                         bit_array.AppendLine ("");
1074                         bit_array.AppendLine (tabs + "};");
1075                         bit_array.AppendLine (tabs + "};");
1076                         WriteLineNonFormat (bit_array.ToString ());
1077                         WriteLine ("BitArray bits = new BitArray (answers);");
1078                         WriteLine ("for (int i = 0; i < (int) char.MaxValue; i++)");
1079                         WriteLine ("\tAssert.AreEqual (bits.Get (i), MaskedTextProvider.IsValidMaskChar ((char) i), \"{0}#\" + i.ToString ());", TestName);
1080
1081                         WriteTestEnd ();
1082                         WriteTestFooter ();
1083                 }
1084                 static void GenerateIsValidPasswordCharTest ()
1085                 {
1086                         string TestName = "IsValidPasswordCharGenerated";
1087
1088                         dont_write = true;
1089                 doagain:
1090
1091                         WriteTestHeader (TestName);
1092                         WriteTestStart ();
1093
1094
1095                         int max = (int)char.MaxValue;
1096                         BitArray bits = new BitArray (max);
1097                         for (int i = 0; i < max; i++) {
1098                                 bool result_MS = MS_System_ComponentModel.MaskedTextProvider.IsValidPasswordChar ((char)i);
1099                                 bool result_Mono = MaskedTextProvider.IsValidPasswordChar ((char)i);
1100                                 if (dont_write && (result_MS != result_Mono)) {
1101                                         dont_write = false;
1102                                         goto doagain;
1103                                 }
1104                                 bits.Set (i, MS_System_ComponentModel.MaskedTextProvider.IsValidPasswordChar ((char)i));
1105                         }
1106                         StringBuilder bit_array = new StringBuilder ();
1107                         bit_array.AppendLine ("int [] answers;");
1108                         bit_array.AppendLine (tabs + "unchecked {");
1109                         bit_array.Append (tabs + "answers = new int [] {");
1110                         int [] numbers = new int [max / 32 + 1];
1111                         bits.CopyTo (numbers, 0);
1112                         for (int i = 0; i < numbers.Length; i++) {
1113                                 if (i % 8 == 0) {
1114                                         bit_array.AppendLine ("");
1115                                         bit_array.Append (tabs + "\t");
1116                                 }
1117                                 bit_array.Append (String.Format ("(int) 0x{0:X8}", numbers [i]));
1118                                 if (i != numbers.Length - 1)
1119                                         bit_array.Append (", ");
1120
1121                         }
1122                         bit_array.AppendLine ("");
1123                         bit_array.AppendLine (tabs + "};");
1124                         bit_array.AppendLine (tabs + "};");
1125                         WriteLineNonFormat (bit_array.ToString ());
1126                         WriteLine ("BitArray bits = new BitArray (answers);");
1127                         WriteLine ("for (int i = 0; i < (int) char.MaxValue; i++)");
1128                         WriteLine ("\tAssert.AreEqual (bits.Get (i), MaskedTextProvider.IsValidPasswordChar ((char) i), \"{0}#\" + i.ToString ());", TestName);
1129
1130                         WriteTestEnd ();
1131                         WriteTestFooter ();
1132                 }
1133
1134                 static void GenerateItemTest ()
1135                 {
1136                         string Name = "mtp";
1137                         string TestName = MethodInfo.GetCurrentMethod ().Name.Replace ("Generate", "");
1138                         int counter = 0;
1139
1140                         WriteTestHeader (TestName, "MaskedTextProvider mtp;", "int Int32_out = 0;", "MaskedTextResultHint MaskedTextResultHint_out = MaskedTextResultHint.Unknown;");
1141                         MS_System_ComponentModel.MaskedTextProvider mtp = null;
1142
1143                         foreach (string mask in test_masks) {
1144                                 for (int i = 0; i < mask.Length; i++) {
1145                                         bool more_states = true;
1146                                         int stateindex = 0;
1147                                         do {
1148                                                 mtp = new MS_System_ComponentModel.MaskedTextProvider (mask);
1149
1150                                                 if (i >= mtp.Length)
1151                                                         break;
1152
1153                                                 object [] arguments;
1154                                                 arguments = new object [] { i };
1155                                                 if (Compare ("Item", mask, ref stateindex, arguments, ref more_states)) {
1156                                                         continue;
1157                                                 }
1158
1159                                                 WriteTestStart ();
1160                                                 WriteLine ("mtp = new MaskedTextProvider (@\"" + mask.Replace ("\"", "\"\"") + "\");");
1161                                                 more_states = CreateState (mtp, stateindex);
1162                                                 stateindex++;
1163
1164                                                 WriteLine ("Assert.AreEqual ({0}, mtp [{1}], \"#{2}\");", GetStringValue (mtp [i]), i.ToString (), (counter++).ToString ());
1165                                                 WriteAssertProperties (mtp, Name, TestName, ref counter);
1166
1167                                                 WriteTestEnd ();
1168
1169                                         } while (more_states);
1170                                 }
1171                         }
1172
1173                         WriteTestFooter ();
1174
1175                 }
1176
1177                 static void GenerateRemoveTest ()
1178                 {
1179                         string Name = "mtp";
1180                         string TestName = MethodInfo.GetCurrentMethod ().Name.Replace ("Generate", "");
1181                         int counter = 0;
1182
1183                         WriteTestHeader (TestName, "MaskedTextProvider mtp;", "int Int32_out = 0;", "MaskedTextResultHint MaskedTextResultHint_out = MaskedTextResultHint.Unknown;");
1184                         MS_System_ComponentModel.MaskedTextProvider mtp = null;
1185                         //int Int32_out = 0;
1186                         //MS_System_ComponentModel.MaskedTextResultHint MaskedTextResultHint_out = MS_System_ComponentModel.MaskedTextResultHint.Unknown;
1187
1188                         foreach (string mask in test_masks) {
1189                                 bool more_states = true;
1190                                 int stateindex = 0;
1191                                 do {
1192
1193                                         object [] arguments;
1194                                         arguments = new object [] { };
1195                                         if (Compare ("Remove", mask, ref stateindex, arguments, ref more_states)) {
1196                                                 continue;
1197                                         }
1198
1199
1200                                         WriteTestStart ();
1201                                         mtp = new MS_System_ComponentModel.MaskedTextProvider (mask);
1202                                         WriteLine ("mtp = new MaskedTextProvider (@\"" + mask.Replace ("\"", "\"\"") + "\");");
1203                                         more_states = CreateState (mtp, stateindex);
1204                                         stateindex++;
1205
1206                                         for (int i = -1; i < mask.Length + 2; i++) {
1207                                                 WriteLine ("Assert.AreEqual ({0}, mtp.Remove (), \"#{1}\");", GetStringValue (mtp.Remove ()), (counter++).ToString ());
1208                                                 WriteAssertProperties (mtp, Name, TestName, ref counter);
1209                                         }
1210                                         WriteTestEnd ();
1211
1212                                 } while (more_states);
1213                         }
1214
1215                         WriteTestFooter ();
1216                 }
1217                 static void GenerateRemove_int_MaskedTextResultHintTest ()
1218                 {
1219                         string Name = "mtp";
1220                         string TestName = MethodInfo.GetCurrentMethod ().Name.Replace ("Generate", "");
1221                         int counter = 0;
1222
1223                         WriteTestHeader (TestName, "MaskedTextProvider mtp;", "int Int32_out = 0;", "MaskedTextResultHint MaskedTextResultHint_out = MaskedTextResultHint.Unknown;");
1224                         MS_System_ComponentModel.MaskedTextProvider mtp = null;
1225                         int Int32_out = 0;
1226                         MS_System_ComponentModel.MaskedTextResultHint MaskedTextResultHint_out = MS_System_ComponentModel.MaskedTextResultHint.Unknown;
1227
1228                         foreach (string mask in test_masks) {
1229                                 bool more_states = true;
1230                                 int stateindex = 0;
1231                                 do {
1232
1233                                         object [] arguments;
1234                                         arguments = new object [] { Int32_out, MaskedTextResultHint_out };
1235                                         if (Compare ("Remove", mask, ref stateindex, arguments, ref more_states)) {
1236                                                 continue;
1237                                         }
1238
1239                                         WriteTestStart ();
1240                                         mtp = new MS_System_ComponentModel.MaskedTextProvider (mask);
1241                                         WriteLine ("mtp = new MaskedTextProvider (@\"" + mask.Replace ("\"", "\"\"") + "\");");
1242                                         more_states = CreateState (mtp, stateindex);
1243                                         stateindex++;
1244
1245                                         for (int i = -1; i < mask.Length + 2; i++) {
1246                                                 WriteLine ("Assert.AreEqual ({0}, mtp.Remove (out Int32_out, out MaskedTextResultHint_out), \"#{1}\");", GetStringValue (mtp.Remove (out Int32_out, out MaskedTextResultHint_out)), (counter++).ToString ());
1247                                                 WriteLine ("Assert.AreEqual ({0}, Int32_out, \"#{1}\");", GetStringValue (Int32_out), (counter++).ToString ());
1248                                                 WriteLine ("Assert.AreEqual ({0}, MaskedTextResultHint_out, \"#{1}\");", GetStringValue (MaskedTextResultHint_out), (counter++).ToString ());
1249                                                 WriteAssertProperties (mtp, Name, TestName, ref counter);
1250                                         }
1251                                         WriteTestEnd ();
1252                                 } while (more_states);
1253                         }
1254
1255                         WriteTestFooter ();
1256                 }
1257                 static void GenerateRemoveAt_int_Test ()
1258                 {
1259                         string Name = "mtp";
1260                         string TestName = MethodInfo.GetCurrentMethod ().Name.Replace ("Generate", "");
1261                         int counter = 0;
1262
1263
1264                         WriteTestHeader (TestName, "MaskedTextProvider mtp;", "int Int32_out = 0;", "MaskedTextResultHint MaskedTextResultHint_out = MaskedTextResultHint.Unknown;");
1265                         MS_System_ComponentModel.MaskedTextProvider mtp = null;
1266                         //int Int32_out = 0;
1267                         //MS_System_ComponentModel.MaskedTextResultHint MaskedTextResultHint_out = MS_System_ComponentModel.MaskedTextResultHint.Unknown;
1268
1269                         foreach (string mask in test_masks) {
1270                                 for (int i = 0; i < mask.Length; i++) {
1271                                         bool more_states = true;
1272                                         int stateindex = 0;
1273                                         do {
1274
1275                                                 object [] arguments;
1276                                                 arguments = new object [] { i };
1277                                                 if (Compare ("RemoveAt", mask, ref stateindex, arguments, ref more_states)) {
1278                                                         continue;
1279                                                 }
1280
1281                                                 WriteTestStart ();
1282                                                 mtp = new MS_System_ComponentModel.MaskedTextProvider (mask);
1283                                                 WriteLine ("mtp = new MaskedTextProvider (@\"" + mask.Replace ("\"", "\"\"") + "\");");
1284                                                 more_states = CreateState (mtp, stateindex);
1285                                                 stateindex++;
1286
1287                                                 WriteLine ("Assert.AreEqual ({0}, mtp.RemoveAt ({1}), \"#{2}\");",
1288                                                         GetStringValue (mtp.RemoveAt (i)), i.ToString (), (counter++).ToString ());
1289
1290                                                 WriteAssertProperties (mtp, Name, TestName, ref counter);
1291                                                 WriteTestEnd ();
1292
1293                                         } while (more_states);
1294                                 }
1295                         }
1296
1297                         WriteTestFooter ();
1298                 }
1299                 static void GenerateRemoveAt_int_int_Test ()
1300                 {
1301                         string Name = "mtp";
1302                         string TestName = MethodInfo.GetCurrentMethod ().Name.Replace ("Generate", "");
1303                         int counter = 0;
1304
1305                         WriteTestHeader (TestName, "MaskedTextProvider mtp;", "int Int32_out = 0;", "MaskedTextResultHint MaskedTextResultHint_out = MaskedTextResultHint.Unknown;");
1306                         MS_System_ComponentModel.MaskedTextProvider mtp = null;
1307                         //int Int32_out = 0;
1308                         //MS_System_ComponentModel.MaskedTextResultHint MaskedTextResultHint_out = MS_System_ComponentModel.MaskedTextResultHint.Unknown;
1309
1310                         foreach (string mask in test_masks) {
1311                                 for (int i = 0; i < mask.Length; i++) {
1312                                         for (int j = 0; j < mask.Length; j++) {
1313                                                 bool more_states = true;
1314                                                 int stateindex = 0;
1315                                                 do {
1316                                                         object [] arguments;
1317                                                         arguments = new object [] { i, j };
1318                                                         if (Compare ("RemoveAt", mask, ref stateindex, arguments, ref more_states)) {
1319                                                                 continue;
1320                                                         }
1321
1322                                                         WriteTestStart ();
1323                                                         mtp = new MS_System_ComponentModel.MaskedTextProvider (mask);
1324                                                         WriteLine ("mtp = new MaskedTextProvider (@\"" + mask.Replace ("\"", "\"\"") + "\");");
1325                                                         more_states = CreateState (mtp, stateindex);
1326                                                         stateindex++;
1327
1328                                                         WriteLine ("Assert.AreEqual ({0}, mtp.RemoveAt ({1}, {2}), \"#{3}\");",
1329                                                                 GetStringValue (mtp.RemoveAt (i, j)), i.ToString (), j.ToString (), (counter++).ToString ());
1330
1331                                                         WriteAssertProperties (mtp, Name, TestName, ref counter);
1332                                                         WriteTestEnd ();
1333
1334                                                 } while (more_states);
1335                                         }
1336                                 }
1337                         }
1338
1339                         WriteTestFooter ();
1340                 }
1341                 static void GenerateRemoveAt_int_int_int_MaskedTextResultHintTest ()
1342                 {
1343                         string Name = "mtp";
1344                         string TestName = MethodInfo.GetCurrentMethod ().Name.Replace ("Generate", "");
1345                         int counter = 0;
1346
1347                         WriteTestHeader (TestName, "MaskedTextProvider mtp;", "int Int32_out = 0;", "MaskedTextResultHint MaskedTextResultHint_out = MaskedTextResultHint.Unknown;");
1348                         MS_System_ComponentModel.MaskedTextProvider mtp = null;
1349                         //object mtp_MS, mtp_Mono;
1350                         int Int32_out = 0;
1351                         MS_System_ComponentModel.MaskedTextResultHint MaskedTextResultHint_out = MS_System_ComponentModel.MaskedTextResultHint.Unknown;
1352
1353                         foreach (string mask in test_masks) {
1354                                 for (int i = 0; i < mask.Length; i++) {
1355                                         for (int j = 0; j < mask.Length; j++) {
1356                                                 bool more_states = true;
1357                                                 int stateindex = 0;
1358                                                 do {
1359                                                         object [] arguments;
1360                                                         arguments = new object [] { i, j, Int32_out, MaskedTextResultHint_out };
1361                                                         if (Compare ("RemoveAt", mask, ref stateindex, arguments, ref more_states)) {
1362                                                                 continue;
1363                                                         }
1364
1365                                                         dont_write = false;
1366                                                         WriteTestStart ();
1367                                                         mtp = new MS_System_ComponentModel.MaskedTextProvider (mask);
1368                                                         WriteLine ("mtp = new MaskedTextProvider (@\"" + mask.Replace ("\"", "\"\"") + "\");");
1369                                                         more_states = CreateState (mtp, stateindex);
1370                                                         stateindex++;
1371
1372                                                         WriteLine ("Assert.AreEqual ({0}, mtp.RemoveAt ({1}, {2}, out Int32_out, out MaskedTextResultHint_out), \"#{3}\");",
1373                                                                 GetStringValue (mtp.RemoveAt (i, j, out Int32_out, out MaskedTextResultHint_out)), i.ToString (), j.ToString (), (counter++).ToString ());
1374                                                         WriteLine ("Assert.AreEqual ({0}, Int32_out, \"#{1}\");", GetStringValue (Int32_out), (counter++).ToString ());
1375                                                         WriteLine ("Assert.AreEqual ({0}, MaskedTextResultHint_out, \"#{1}\");", GetStringValue (MaskedTextResultHint_out), (counter++).ToString ());
1376
1377                                                         WriteAssertProperties (mtp, Name, TestName, ref counter);
1378                                                         WriteTestEnd ();
1379
1380                                                 } while (more_states);
1381                                         }
1382                                 }
1383                         }
1384
1385
1386                         WriteTestFooter ();
1387                 }
1388
1389                 static void GenerateReplace_char_int_Test ()
1390                 {
1391                         string Name = "mtp";
1392                         string TestName = MethodInfo.GetCurrentMethod ().Name.Replace ("Generate", "");
1393                         int counter = 0;
1394
1395                         WriteTestHeader (TestName, "MaskedTextProvider mtp;", "int Int32_out = 0;", "MaskedTextResultHint MaskedTextResultHint_out = MaskedTextResultHint.Unknown;");
1396                         MS_System_ComponentModel.MaskedTextProvider mtp = null;
1397                         //int Int32_out = 0;
1398                         //MS_System_ComponentModel.MaskedTextResultHint MaskedTextResultHint_out = MS_System_ComponentModel.MaskedTextResultHint.Unknown;
1399
1400                         foreach (string mask in test_masks) {
1401                                 foreach (char str in char_values) {
1402                                         for (int i = 0; i < mask.Length; i++) {
1403                                                 bool more_states = true;
1404                                                 int stateindex = 0;
1405                                                 do {
1406                                                         object [] arguments;
1407                                                         arguments = new object [] { str, i };
1408                                                         if (Compare ("Replace", mask, ref stateindex, arguments, ref more_states)) {
1409                                                                 continue;
1410                                                         }
1411
1412                                                         WriteTestStart ();
1413                                                         mtp = new MS_System_ComponentModel.MaskedTextProvider (mask);
1414                                                         WriteLine ("mtp = new MaskedTextProvider (@\"" + mask.Replace ("\"", "\"\"") + "\");");
1415                                                         more_states = CreateState (mtp, stateindex);
1416                                                         stateindex++;
1417
1418                                                         WriteLine ("Assert.AreEqual ({0}, mtp.Replace ({1}, {2}), \"#{3}\");",
1419                                                                 GetStringValue (mtp.Replace (str, i)), GetStringValue (str), i.ToString (), (counter++).ToString ());
1420
1421                                                         WriteAssertProperties (mtp, Name, TestName, ref counter);
1422                                                         WriteTestEnd ();
1423
1424                                                 } while (more_states);
1425                                         }
1426                                 }
1427                         }
1428
1429                         WriteTestFooter ();
1430                 }
1431                 static void GenerateReplace_string_int_Test ()
1432                 {
1433                         string Name = "mtp";
1434                         string TestName = MethodInfo.GetCurrentMethod ().Name.Replace ("Generate", "");
1435                         int counter = 0;
1436
1437                         WriteTestHeader (TestName, "MaskedTextProvider mtp;", "int Int32_out = 0;", "MaskedTextResultHint MaskedTextResultHint_out = MaskedTextResultHint.Unknown;");
1438                         MS_System_ComponentModel.MaskedTextProvider mtp = null;
1439                         //int Int32_out = 0;
1440                         //MS_System_ComponentModel.MaskedTextResultHint MaskedTextResultHint_out = MS_System_ComponentModel.MaskedTextResultHint.Unknown;
1441
1442                         foreach (string mask in test_masks) {
1443                                 foreach (string str in string_values) {
1444                                         if (str == null)
1445                                                 continue;
1446
1447                                         for (int i = 0; i < mask.Length; i++) {
1448                                                 bool more_states = true;
1449                                                 int stateindex = 0;
1450                                                 do {
1451                                                         object [] arguments;
1452                                                         arguments = new object [] { str, i };
1453                                                         if (Compare ("Replace", mask, ref stateindex, arguments, ref more_states)) {
1454                                                                 continue;
1455                                                         }
1456
1457                                                         WriteTestStart ();
1458                                                         mtp = new MS_System_ComponentModel.MaskedTextProvider (mask);
1459                                                         WriteLine ("mtp = new MaskedTextProvider (@\"" + mask.Replace ("\"", "\"\"") + "\");");
1460                                                         more_states = CreateState (mtp, stateindex);
1461                                                         stateindex++;
1462
1463                                                         WriteLine ("Assert.AreEqual ({0}, mtp.Replace ({1}, {2}), \"#{3}\");",
1464                                                                 GetStringValue (mtp.Replace (str, i)), GetStringValue (str), i.ToString (), (counter++).ToString ());
1465
1466                                                         WriteAssertProperties (mtp, Name, TestName, ref counter);
1467                                                         WriteTestEnd ();
1468                                                 } while (more_states);
1469                                         }
1470                                 }
1471                         }
1472
1473                         WriteTestFooter ();
1474                 }
1475                 static void GenerateReplace_char_int_int_MaskedTextResultHintTest ()
1476                 {
1477                         string Name = "mtp";
1478                         string TestName = MethodInfo.GetCurrentMethod ().Name.Replace ("Generate", "");
1479                         int counter = 0;
1480
1481                         WriteTestHeader (TestName, "MaskedTextProvider mtp;", "int Int32_out = 0;", "MaskedTextResultHint MaskedTextResultHint_out = MaskedTextResultHint.Unknown;");
1482                         MS_System_ComponentModel.MaskedTextProvider mtp = null;
1483                         int Int32_out = 0;
1484                         MS_System_ComponentModel.MaskedTextResultHint MaskedTextResultHint_out = MS_System_ComponentModel.MaskedTextResultHint.Unknown;
1485
1486                         foreach (string mask in test_masks) {
1487                                 foreach (char str in char_values) {
1488                                         for (int i = 0; i < mask.Length; i++) {
1489                                                 bool more_states = true;
1490                                                 int stateindex = 0;
1491                                                 do {
1492                                                         object [] arguments;
1493                                                         arguments = new object [] { str, i, Int32_out, MaskedTextResultHint_out };
1494                                                         if (Compare ("Replace", mask, ref stateindex, arguments, ref more_states)) {
1495                                                                 continue;
1496                                                         }
1497
1498                                                         WriteTestStart ();
1499                                                         mtp = new MS_System_ComponentModel.MaskedTextProvider (mask);
1500                                                         WriteLine ("mtp = new MaskedTextProvider (@\"" + mask.Replace ("\"", "\"\"") + "\");");
1501                                                         more_states = CreateState (mtp, stateindex);
1502                                                         stateindex++;
1503
1504                                                         WriteLine ("Assert.AreEqual ({0}, mtp.Replace ({1}, {2}, out Int32_out, out MaskedTextResultHint_out), \"#{3}\");",
1505                                                                 GetStringValue (mtp.Replace (str, i, out Int32_out, out MaskedTextResultHint_out)), GetStringValue (str), i.ToString (), (counter++).ToString ());
1506                                                         WriteLine ("Assert.AreEqual ({0}, Int32_out, \"#{1}\");", GetStringValue (Int32_out), (counter++).ToString ());
1507                                                         WriteLine ("Assert.AreEqual ({0}, MaskedTextResultHint_out, \"#{1}\");", GetStringValue (MaskedTextResultHint_out), (counter++).ToString ());
1508
1509                                                         WriteAssertProperties (mtp, Name, TestName, ref counter);
1510                                                         WriteTestEnd ();
1511                                                 } while (more_states);
1512                                         }
1513                                 }
1514                         }
1515
1516                         WriteTestFooter ();
1517                 }
1518                 static void GenerateReplace_string_int_int_MaskedTextResultHintTest ()
1519                 {
1520                         string Name = "mtp";
1521                         string TestName = MethodInfo.GetCurrentMethod ().Name.Replace ("Generate", "");
1522                         int counter = 0;
1523
1524
1525                         WriteTestHeader (TestName, "MaskedTextProvider mtp;", "int Int32_out = 0;", "MaskedTextResultHint MaskedTextResultHint_out = MaskedTextResultHint.Unknown;");
1526                         MS_System_ComponentModel.MaskedTextProvider mtp = null;
1527                         int Int32_out = 0;
1528                         MS_System_ComponentModel.MaskedTextResultHint MaskedTextResultHint_out = MS_System_ComponentModel.MaskedTextResultHint.Unknown;
1529
1530                         foreach (string mask in test_masks) {
1531                                 foreach (string str in string_values) {
1532                                         if (str == null)
1533                                                 continue;
1534
1535                                         for (int i = 0; i < mask.Length; i++) {
1536                                                 bool more_states = true;
1537                                                 int stateindex = 0;
1538
1539                                                 do {
1540                                                         object [] arguments;
1541                                                         arguments = new object [] { str, i, Int32_out, MaskedTextResultHint_out };
1542                                                         if (Compare ("Replace", mask, ref stateindex, arguments, ref more_states)) {
1543                                                                 continue;
1544                                                         }
1545
1546                                                         WriteTestStart ();
1547                                                         mtp = new MS_System_ComponentModel.MaskedTextProvider (mask);
1548                                                         WriteLine ("mtp = new MaskedTextProvider (@\"" + mask.Replace ("\"", "\"\"") + "\");");
1549                                                         more_states = CreateState (mtp, stateindex);
1550                                                         stateindex++;
1551
1552                                                         WriteLine ("Assert.AreEqual ({0}, mtp.Replace ({1}, {2}, out Int32_out, out MaskedTextResultHint_out), \"#{3}\");",
1553                                                                 GetStringValue (mtp.Replace (str, i, out Int32_out, out MaskedTextResultHint_out)), GetStringValue (str), i.ToString (), (counter++).ToString ());
1554                                                         WriteLine ("Assert.AreEqual ({0}, Int32_out, \"#{1}\");", GetStringValue (Int32_out), (counter++).ToString ());
1555                                                         WriteLine ("Assert.AreEqual ({0}, MaskedTextResultHint_out, \"#{1}\");", GetStringValue (MaskedTextResultHint_out), (counter++).ToString ());
1556
1557                                                         WriteAssertProperties (mtp, Name, TestName, ref counter);
1558                                                         WriteTestEnd ();
1559
1560                                                 } while (more_states);
1561                                         }
1562                                 }
1563                         }
1564
1565                         WriteTestFooter ();
1566                 }
1567                 static void GenerateReplace_char_int_int_int_MaskedTextResultHintTest ()
1568                 {
1569                         string Name = "mtp";
1570                         string TestName = MethodInfo.GetCurrentMethod ().Name.Replace ("Generate", "");
1571                         int counter = 0;
1572
1573                         WriteTestHeader (TestName, "MaskedTextProvider mtp;", "int Int32_out = 0;", "MaskedTextResultHint MaskedTextResultHint_out = MaskedTextResultHint.Unknown;");
1574                         MS_System_ComponentModel.MaskedTextProvider mtp = null;
1575                         int Int32_out = 0;
1576                         MS_System_ComponentModel.MaskedTextResultHint MaskedTextResultHint_out = MS_System_ComponentModel.MaskedTextResultHint.Unknown;
1577
1578                         foreach (string mask in test_masks) {
1579                                 foreach (char str in char_values) {
1580                                         for (int i = 0; i < mask.Length; i++) {
1581                                                 for (int j = 0; j < mask.Length; j++) {
1582                                                         bool more_states = true;
1583                                                         int stateindex = 0;
1584
1585                                                         do {
1586                                                                 object [] arguments;
1587                                                                 arguments = new object [] { str, i, j, Int32_out, MaskedTextResultHint_out };
1588                                                                 if (Compare ("Replace", mask, ref stateindex, arguments, ref more_states)) {
1589                                                                         continue;
1590                                                                 }
1591
1592                                                                 WriteTestStart ();
1593                                                                 mtp = new MS_System_ComponentModel.MaskedTextProvider (mask);
1594                                                                 WriteLine ("mtp = new MaskedTextProvider (@\"" + mask.Replace ("\"", "\"\"") + "\");");
1595                                                                 more_states = CreateState (mtp, stateindex);
1596                                                                 stateindex++;
1597
1598                                                                 WriteLine ("Assert.AreEqual ({0}, mtp.Replace ({1}, {2}, {3}, out Int32_out, out MaskedTextResultHint_out), \"#{4}\");",
1599                                                                         GetStringValue (mtp.Replace (str, i, j, out Int32_out, out MaskedTextResultHint_out)), GetStringValue (str), i.ToString (), j.ToString (), (counter++).ToString ());
1600                                                                 WriteLine ("Assert.AreEqual ({0}, Int32_out, \"#{1}\");", GetStringValue (Int32_out), (counter++).ToString ());
1601                                                                 WriteLine ("Assert.AreEqual ({0}, MaskedTextResultHint_out, \"#{1}\");", GetStringValue (MaskedTextResultHint_out), (counter++).ToString ());
1602
1603                                                                 WriteAssertProperties (mtp, Name, TestName, ref counter);
1604                                                                 WriteTestEnd ();
1605
1606                                                         } while (more_states);
1607                                                 }
1608                                         }
1609                                 }
1610                         }
1611                         WriteTestFooter ();
1612                 }
1613                 static void GenerateReplace_string_int_int_int_MaskedTextResultHintTest ()
1614                 {
1615                         string Name = "mtp";
1616                         string TestName = MethodInfo.GetCurrentMethod ().Name.Replace ("Generate", "");
1617                         int counter = 0;
1618
1619                         WriteTestHeader (TestName, "MaskedTextProvider mtp;", "int Int32_out = 0;", "MaskedTextResultHint MaskedTextResultHint_out = MaskedTextResultHint.Unknown;");
1620                         MS_System_ComponentModel.MaskedTextProvider mtp = null;
1621                         int Int32_out = 0;
1622                         MS_System_ComponentModel.MaskedTextResultHint MaskedTextResultHint_out = MS_System_ComponentModel.MaskedTextResultHint.Unknown;
1623
1624                         foreach (string mask in test_masks) {
1625                                 foreach (string str in string_values) {
1626                                         if (str == null)
1627                                                 continue;
1628
1629                                         for (int i = 0; i < mask.Length; i++) {
1630                                                 for (int j = 0; j < mask.Length; j++) {
1631                                                         bool more_states = true;
1632                                                         int stateindex = 0;
1633
1634                                                         do {
1635                                                                 object [] arguments;
1636                                                                 arguments = new object [] { str, i, j, Int32_out, MaskedTextResultHint_out };
1637                                                                 if (Compare ("Replace", mask, ref stateindex, arguments, ref more_states)) {
1638                                                                         continue;
1639                                                                 }
1640
1641                                                                 WriteTestStart ();
1642                                                                 mtp = new MS_System_ComponentModel.MaskedTextProvider (mask);
1643                                                                 WriteLine ("mtp = new MaskedTextProvider (@\"" + mask.Replace ("\"", "\"\"") + "\");");
1644                                                                 more_states = CreateState (mtp, stateindex);
1645                                                                 stateindex++;
1646
1647                                                                 WriteLine ("Assert.AreEqual ({0}, mtp.Replace ({1}, {2}, {3}, out Int32_out, out MaskedTextResultHint_out), \"#{4}\");",
1648                                                                         GetStringValue (mtp.Replace (str, i, j, out Int32_out, out MaskedTextResultHint_out)), GetStringValue (str), i.ToString (), j.ToString (), (counter++).ToString ());
1649                                                                 WriteLine ("Assert.AreEqual ({0}, Int32_out, \"#{1}\");", GetStringValue (Int32_out), (counter++).ToString ());
1650                                                                 WriteLine ("Assert.AreEqual ({0}, MaskedTextResultHint_out, \"#{1}\");", GetStringValue (MaskedTextResultHint_out), (counter++).ToString ());
1651
1652                                                                 WriteAssertProperties (mtp, Name, TestName, ref counter);
1653                                                                 WriteTestEnd ();
1654
1655                                                         } while (more_states && current_test_counter < MAXFAILEDTESTS);
1656                                                 }
1657                                         }
1658                                 }
1659                         }
1660
1661                         WriteTestFooter ();
1662                 }
1663
1664                 static void GenerateSet_string_Test ()
1665                 {
1666                         string Name = "mtp";
1667                         string TestName = MethodInfo.GetCurrentMethod ().Name.Replace ("Generate", "");
1668                         int counter = 0;
1669
1670                         WriteTestHeader (TestName, "MaskedTextProvider mtp;", "int Int32_out = 0;", "MaskedTextResultHint MaskedTextResultHint_out = MaskedTextResultHint.Unknown;");
1671                         MS_System_ComponentModel.MaskedTextProvider mtp = null;
1672                         //int Int32_out = 0;
1673                         //MS_System_ComponentModel.MaskedTextResultHint MaskedTextResultHint_out = MS_System_ComponentModel.MaskedTextResultHint.Unknown;
1674
1675                         foreach (string mask in test_masks) {
1676                                 foreach (string str in string_values) {
1677                                         if (str == null)
1678                                                 continue;
1679
1680                                         bool more_states = true;
1681                                         int stateindex = 0;
1682                                         do {
1683                                                 object [] arguments;
1684                                                 arguments = new object [] { str };
1685                                                 if (Compare ("Set", mask, ref stateindex, arguments, ref more_states)) {
1686                                                         continue;
1687                                                 }
1688
1689                                                 WriteTestStart ();
1690                                                 mtp = new MS_System_ComponentModel.MaskedTextProvider (mask);
1691                                                 WriteLine ("mtp = new MaskedTextProvider (@\"" + mask.Replace ("\"", "\"\"") + "\");");
1692                                                 more_states = CreateState (mtp, stateindex);
1693                                                 stateindex++;
1694
1695                                                 WriteLine ("Assert.AreEqual ({0}, mtp.Set ({1}), \"#{2}\");",
1696                                                         GetStringValue (mtp.Set (str)), GetStringValue (str), (counter++).ToString ());
1697
1698                                                 WriteAssertProperties (mtp, Name, TestName, ref counter);
1699                                                 WriteTestEnd ();
1700
1701                                         } while (more_states);
1702
1703                                 }
1704                         }
1705
1706                         WriteTestFooter ();
1707                 }
1708                 static void GenerateSet_string_int_MaskedTextResultHintTest ()
1709                 {
1710                         string Name = "mtp";
1711                         string TestName = MethodInfo.GetCurrentMethod ().Name.Replace ("Generate", "");
1712                         int counter = 0;
1713
1714                         WriteTestHeader (TestName, "MaskedTextProvider mtp;", "int Int32_out = 0;", "MaskedTextResultHint MaskedTextResultHint_out = MaskedTextResultHint.Unknown;");
1715                         MS_System_ComponentModel.MaskedTextProvider mtp = null;
1716                         int Int32_out = 0;
1717                         MS_System_ComponentModel.MaskedTextResultHint MaskedTextResultHint_out = MS_System_ComponentModel.MaskedTextResultHint.Unknown;
1718
1719                         foreach (string mask in test_masks) {
1720                                 foreach (string str in string_values) {
1721                                         if (str == null)
1722                                                 continue;
1723
1724                                         bool more_states = true;
1725                                         int stateindex = 0;
1726                                         do {
1727                                                 object [] arguments;
1728                                                 arguments = new object [] { str, Int32_out, MaskedTextResultHint_out };
1729                                                 if (Compare ("Set", mask, ref stateindex, arguments, ref more_states)) {
1730                                                         continue;
1731                                                 }
1732
1733                                                 WriteTestStart ();
1734                                                 mtp = new MS_System_ComponentModel.MaskedTextProvider (mask);
1735                                                 WriteLine ("mtp = new MaskedTextProvider (@\"" + mask.Replace ("\"", "\"\"") + "\");");
1736                                                 more_states = CreateState (mtp, stateindex);
1737                                                 stateindex++;
1738
1739                                                 WriteLine ("Assert.AreEqual ({0}, mtp.Set ({1}, out Int32_out, out MaskedTextResultHint_out), \"#{2}\");",
1740                                                         GetStringValue (mtp.Set (str, out Int32_out, out MaskedTextResultHint_out)), GetStringValue (str), (counter++).ToString ());
1741                                                 WriteLine ("Assert.AreEqual ({0}, Int32_out, \"#{1}\");", GetStringValue (Int32_out), (counter++).ToString ());
1742                                                 WriteLine ("Assert.AreEqual ({0}, MaskedTextResultHint_out, \"#{1}\");", GetStringValue (MaskedTextResultHint_out), (counter++).ToString ());
1743
1744                                                 WriteAssertProperties (mtp, Name, TestName, ref counter);
1745                                                 WriteTestEnd ();
1746
1747                                         } while (more_states);
1748
1749                                 }
1750                         }
1751
1752                         WriteTestFooter ();
1753                 }
1754
1755                 static void GenerateToDisplayStringTest ()
1756                 {
1757                         string Name = "mtp";
1758                         string TestName = MethodInfo.GetCurrentMethod ().Name.Replace ("Generate", "");
1759                         int counter = 0;
1760
1761                         WriteTestHeader (TestName, "MaskedTextProvider mtp;", "int Int32_out = 0;", "MaskedTextResultHint MaskedTextResultHint_out = MaskedTextResultHint.Unknown;");
1762                         MS_System_ComponentModel.MaskedTextProvider mtp = null;
1763                         //int Int32_out = 0;
1764                         //MS_System_ComponentModel.MaskedTextResultHint MaskedTextResultHint_out = MS_System_ComponentModel.MaskedTextResultHint.Unknown;
1765
1766                         foreach (string mask in test_masks) {
1767                                 bool more_states = true;
1768                                 int stateindex = 0;
1769                                 do {
1770                                         object [] arguments;
1771                                         arguments = new object [] { };
1772                                         if (Compare ("ToDisplayString", mask, ref stateindex, arguments, ref more_states)) {
1773                                                 continue;
1774                                         }
1775
1776                                         WriteTestStart ();
1777                                         mtp = new MS_System_ComponentModel.MaskedTextProvider (mask);
1778                                         WriteLine ("mtp = new MaskedTextProvider (@\"" + mask.Replace ("\"", "\"\"") + "\");");
1779                                         more_states = CreateState (mtp, stateindex);
1780                                         stateindex++;
1781
1782                                         WriteLine ("Assert.AreEqual ({0}, mtp.ToDisplayString (), \"#{1}\");",
1783                                                 GetStringValue (mtp.ToDisplayString ()), (counter++).ToString ());
1784
1785                                         WriteAssertProperties (mtp, Name, TestName, ref counter);
1786                                         WriteTestEnd ();
1787
1788                                 } while (more_states);
1789                         }
1790
1791                         WriteTestFooter ();
1792                 }
1793                 static void GenerateToStringTest ()
1794                 {
1795                         string Name = "mtp";
1796                         string TestName = MethodInfo.GetCurrentMethod ().Name.Replace ("Generate", "");
1797                         int counter = 0;
1798
1799                         WriteTestHeader (TestName, "MaskedTextProvider mtp;", "int Int32_out = 0;", "MaskedTextResultHint MaskedTextResultHint_out = MaskedTextResultHint.Unknown;");
1800                         MS_System_ComponentModel.MaskedTextProvider mtp = null;
1801                         //int Int32_out = 0;
1802                         //MS_System_ComponentModel.MaskedTextResultHint MaskedTextResultHint_out = MS_System_ComponentModel.MaskedTextResultHint.Unknown;
1803
1804                         foreach (string mask in test_masks) {
1805                                 bool more_states = true;
1806                                 int stateindex = 0;
1807                                 do {
1808                                         object [] arguments;
1809                                         arguments = new object [] { };
1810                                         if (Compare ("ToString", mask, ref stateindex, arguments, ref more_states)) {
1811                                                 continue;
1812                                         }
1813
1814                                         WriteTestStart ();
1815                                         mtp = new MS_System_ComponentModel.MaskedTextProvider (mask);
1816                                         WriteLine ("mtp = new MaskedTextProvider (@\"" + mask.Replace ("\"", "\"\"") + "\");");
1817                                         more_states = CreateState (mtp, stateindex);
1818                                         stateindex++;
1819
1820                                         WriteLine ("Assert.AreEqual ({0}, mtp.ToString (), \"#{1}\");",
1821                                                 GetStringValue (mtp.ToString ()), (counter++).ToString ());
1822
1823                                         WriteAssertProperties (mtp, Name, TestName, ref counter);
1824                                         WriteTestEnd ();
1825
1826                                 } while (more_states);
1827                         }
1828                         WriteTestFooter ();
1829                 }
1830                 static void GenerateToString_bool_Test ()
1831                 {
1832                         string Name = "mtp";
1833                         string TestName = MethodInfo.GetCurrentMethod ().Name.Replace ("Generate", "");
1834                         int counter = 0;
1835
1836                         WriteTestHeader (TestName, "MaskedTextProvider mtp;", "int Int32_out = 0;", "MaskedTextResultHint MaskedTextResultHint_out = MaskedTextResultHint.Unknown;");
1837                         MS_System_ComponentModel.MaskedTextProvider mtp = null;
1838                         //int Int32_out = 0;
1839                         //MS_System_ComponentModel.MaskedTextResultHint MaskedTextResultHint_out = MS_System_ComponentModel.MaskedTextResultHint.Unknown;
1840
1841                         foreach (string mask in test_masks) {
1842                                 bool more_states = true;
1843                                 foreach (bool value in new bool [] { true, false }) {
1844                                         int stateindex = 0;
1845                                         do {
1846                                                 object [] arguments;
1847                                                 arguments = new object [] { value };
1848                                                 if (Compare ("ToString", mask, ref stateindex, arguments, ref more_states)) {
1849                                                         continue;
1850                                                 }
1851
1852                                                 WriteTestStart ();
1853                                                 mtp = new MS_System_ComponentModel.MaskedTextProvider (mask);
1854                                                 WriteLine ("mtp = new MaskedTextProvider (@\"" + mask.Replace ("\"", "\"\"") + "\");");
1855                                                 more_states = CreateState (mtp, stateindex);
1856                                                 stateindex++;
1857
1858                                                 WriteLine ("Assert.AreEqual ({0}, mtp.ToString ({2}), \"#{1}\");",
1859                                                         GetStringValue (mtp.ToString (value)), (counter++).ToString (), value ? "true" : "false");
1860
1861                                                 WriteAssertProperties (mtp, Name, TestName, ref counter);
1862                                                 WriteTestEnd ();
1863                                         } while (more_states);
1864                                 }
1865                         }
1866
1867                         WriteTestFooter ();
1868                 }
1869                 static void GenerateToString_bool_bool_Test ()
1870                 {
1871                         string Name = "mtp";
1872                         string TestName = MethodInfo.GetCurrentMethod ().Name.Replace ("Generate", "");
1873                         int counter = 0;
1874
1875                         WriteTestHeader (TestName, "MaskedTextProvider mtp;", "int Int32_out = 0;", "MaskedTextResultHint MaskedTextResultHint_out = MaskedTextResultHint.Unknown;");
1876                         MS_System_ComponentModel.MaskedTextProvider mtp = null;
1877                         //int Int32_out = 0;
1878                         //MS_System_ComponentModel.MaskedTextResultHint MaskedTextResultHint_out = MS_System_ComponentModel.MaskedTextResultHint.Unknown;
1879
1880                         foreach (string mask in test_masks) {
1881                                 foreach (bool value1 in new bool [] { true, false }) {
1882                                         foreach (bool value2 in new bool [] { true, false }) {
1883                                                 bool more_states = true;
1884                                                 int stateindex = 0;
1885                                                 do {
1886                                                         object [] arguments;
1887                                                         arguments = new object [] { value1, value2 };
1888                                                         if (Compare ("ToString", mask, ref stateindex, arguments, ref more_states)) {
1889                                                                 continue;
1890                                                         }
1891
1892                                                         WriteTestStart ();
1893                                                         mtp = new MS_System_ComponentModel.MaskedTextProvider (mask);
1894                                                         WriteLine ("mtp = new MaskedTextProvider (@\"" + mask.Replace ("\"", "\"\"") + "\");");
1895                                                         more_states = CreateState (mtp, stateindex);
1896                                                         stateindex++;
1897
1898                                                         WriteLine ("Assert.AreEqual ({0}, mtp.ToString ({2}, {3}), \"#{1}\");",
1899                                                                 GetStringValue (mtp.ToString (value1, value2)), (counter++).ToString (), value1 ? "true" : "false", value2 ? "true" : "false");
1900
1901                                                         WriteAssertProperties (mtp, Name, TestName, ref counter);
1902                                                         WriteTestEnd ();
1903
1904                                                 } while (more_states);
1905                                         }
1906                                 }
1907                         }
1908
1909                         WriteTestFooter ();
1910                 }
1911                 static void GenerateToString_int_int_Test ()
1912                 {
1913                         string Name = "mtp";
1914                         string TestName = MethodInfo.GetCurrentMethod ().Name.Replace ("Generate", "");
1915                         int counter = 0;
1916
1917                         WriteTestHeader (TestName, "MaskedTextProvider mtp;", "int Int32_out = 0;", "MaskedTextResultHint MaskedTextResultHint_out = MaskedTextResultHint.Unknown;");
1918                         MS_System_ComponentModel.MaskedTextProvider mtp = null;
1919                         //int Int32_out = 0;
1920                         //MS_System_ComponentModel.MaskedTextResultHint MaskedTextResultHint_out = MS_System_ComponentModel.MaskedTextResultHint.Unknown;
1921
1922                         foreach (string mask in test_masks) {
1923                                 for (int i = -1; i < mask.Length + 1; i++) {
1924                                         for (int j = -1; j < mask.Length + 1; j++) {
1925
1926                                                 bool more_states = true;
1927                                                 int stateindex = 0;
1928                                                 do {
1929                                                         object [] arguments;
1930                                                         arguments = new object [] { i, j };
1931                                                         if (Compare ("ToString", mask, ref stateindex, arguments, ref more_states)) {
1932                                                                 continue;
1933                                                         }
1934
1935                                                         WriteTestStart ();
1936                                                         mtp = new MS_System_ComponentModel.MaskedTextProvider (mask);
1937                                                         WriteLine ("mtp = new MaskedTextProvider (@\"" + mask.Replace ("\"", "\"\"") + "\");");
1938                                                         more_states = CreateState (mtp, stateindex);
1939                                                         stateindex++;
1940
1941                                                         WriteLine ("Assert.AreEqual ({0}, mtp.ToString ({2}, {3}), \"#{1}\");",
1942                                                                 GetStringValue (mtp.ToString (i, j)), (counter++).ToString (), i.ToString (), j.ToString ());
1943
1944                                                         WriteAssertProperties (mtp, Name, TestName, ref counter);
1945                                                         WriteTestEnd ();
1946                                                 } while (more_states);
1947                                         }
1948                                 }
1949                         }
1950
1951                         WriteTestFooter ();
1952                 }
1953                 static void GenerateToString_bool_int_int_Test ()
1954                 {
1955                         string Name = "mtp";
1956                         string TestName = MethodInfo.GetCurrentMethod ().Name.Replace ("Generate", "");
1957                         int counter = 0;
1958
1959                         WriteTestHeader (TestName, "MaskedTextProvider mtp;", "int Int32_out = 0;", "MaskedTextResultHint MaskedTextResultHint_out = MaskedTextResultHint.Unknown;");
1960                         MS_System_ComponentModel.MaskedTextProvider mtp = null;
1961                         //int Int32_out = 0;
1962                         //MS_System_ComponentModel.MaskedTextResultHint MaskedTextResultHint_out = MS_System_ComponentModel.MaskedTextResultHint.Unknown;
1963
1964                         foreach (string mask in test_masks) {
1965                                 foreach (bool value1 in new bool [] { true, false }) {
1966                                         for (int i = -1; i < mask.Length + 1; i++) {
1967                                                 for (int j = -1; j < mask.Length + 1; j++) {
1968
1969                                                         bool more_states = true;
1970                                                         int stateindex = 0;
1971                                                         do {
1972                                                                 object [] arguments;
1973                                                                 arguments = new object [] { value1, i, j };
1974                                                                 if (Compare ("ToString", mask, ref stateindex, arguments, ref more_states)) {
1975                                                                         continue;
1976                                                                 }
1977
1978                                                                 WriteTestStart ();
1979                                                                 mtp = new MS_System_ComponentModel.MaskedTextProvider (mask);
1980                                                                 WriteLine ("mtp = new MaskedTextProvider (@\"" + mask.Replace ("\"", "\"\"") + "\");");
1981                                                                 more_states = CreateState (mtp, stateindex);
1982                                                                 stateindex++;
1983
1984                                                                 WriteLine ("Assert.AreEqual ({0}, mtp.ToString ({4}, {2}, {3}), \"#{1}\");",
1985                                                                         GetStringValue (mtp.ToString (value1, i, j)), (counter++).ToString (), i.ToString (), j.ToString (), value1 ? "true" : "false");
1986
1987                                                                 WriteAssertProperties (mtp, Name, TestName, ref counter);
1988                                                                 WriteTestEnd ();
1989
1990                                                         } while (more_states);
1991                                                 }
1992                                         }
1993                                 }
1994                         }
1995
1996                         WriteTestFooter ();
1997                 }
1998                 static void GenerateToString_bool_bool_int_int_Test ()
1999                 {
2000                         string Name = "mtp";
2001                         string TestName = MethodInfo.GetCurrentMethod ().Name.Replace ("Generate", "");
2002                         int counter = 0;
2003
2004                         WriteTestHeader (TestName, "MaskedTextProvider mtp;", "int Int32_out = 0;", "MaskedTextResultHint MaskedTextResultHint_out = MaskedTextResultHint.Unknown;");
2005                         MS_System_ComponentModel.MaskedTextProvider mtp = null;
2006                         //int Int32_out = 0;
2007                         //MS_System_ComponentModel.MaskedTextResultHint MaskedTextResultHint_out = MS_System_ComponentModel.MaskedTextResultHint.Unknown;
2008
2009                         foreach (string mask in test_masks) {
2010                                 foreach (bool value1 in new bool [] { true, false }) {
2011                                         foreach (bool value2 in new bool [] { true, false }) {
2012                                                 for (int i = -1; i < mask.Length + 1; i++) {
2013                                                         for (int j = -1; j < mask.Length + 1; j++) {
2014
2015                                                                 bool more_states = true;
2016                                                                 int stateindex = 0;
2017                                                                 do {
2018                                                                         object [] arguments;
2019                                                                         arguments = new object [] { value1, value2, i, j };
2020                                                                         if (Compare ("ToString", mask, ref stateindex, arguments, ref more_states)) {
2021                                                                                 continue;
2022                                                                         }
2023
2024                                                                         WriteTestStart ();
2025                                                                         mtp = new MS_System_ComponentModel.MaskedTextProvider (mask);
2026                                                                         WriteLine ("mtp = new MaskedTextProvider (@\"" + mask.Replace ("\"", "\"\"") + "\");");
2027                                                                         more_states = CreateState (mtp, stateindex);
2028                                                                         stateindex++;
2029
2030                                                                         WriteLine ("Assert.AreEqual ({0}, mtp.ToString ({4}, {5}, {2}, {3}), \"#{1}\");",
2031                                                                                 GetStringValue (mtp.ToString (value1, value2, i, j)), (counter++).ToString (), i.ToString (), j.ToString (), value1 ? "true" : "false", value2 ? "true" : "false");
2032
2033                                                                         WriteAssertProperties (mtp, Name, TestName, ref counter);
2034                                                                         WriteTestEnd ();
2035
2036                                                                 } while (more_states);
2037                                                         }
2038                                                 }
2039                                         }
2040                                 }
2041                         }
2042
2043                         WriteTestFooter ();
2044                 }
2045                 static void GenerateToString_bool_bool_bool_int_int_Test ()
2046                 {
2047                         string Name = "mtp";
2048                         string TestName = MethodInfo.GetCurrentMethod ().Name.Replace ("Generate", "");
2049                         int counter = 0;
2050
2051                         WriteTestHeader (TestName, "MaskedTextProvider mtp;", "int Int32_out = 0;", "MaskedTextResultHint MaskedTextResultHint_out = MaskedTextResultHint.Unknown;");
2052                         MS_System_ComponentModel.MaskedTextProvider mtp = null;
2053                         //int Int32_out = 0;
2054                         //MS_System_ComponentModel.MaskedTextResultHint MaskedTextResultHint_out = MS_System_ComponentModel.MaskedTextResultHint.Unknown;
2055
2056                         foreach (string mask in test_masks) {
2057                                 foreach (bool value1 in new bool [] { true, false }) {
2058                                         foreach (bool value2 in new bool [] { true, false }) {
2059                                                 foreach (bool value3 in new bool [] { true, false }) {
2060                                                         for (int i = -1; i < mask.Length + 1; i++) {
2061                                                                 for (int j = -1; j < mask.Length + 1; j++) {
2062
2063                                                                         bool more_states = true;
2064                                                                         int stateindex = 0;
2065                                                                         do {
2066                                                                                 object [] arguments;
2067                                                                                 arguments = new object [] { value1, value2, value3, i, j };
2068                                                                                 if (Compare ("ToString", mask, ref stateindex, arguments, ref more_states)) {
2069                                                                                         continue;
2070                                                                                 }
2071
2072                                                                                 WriteTestStart ();
2073                                                                                 mtp = new MS_System_ComponentModel.MaskedTextProvider (mask);
2074                                                                                 WriteLine ("mtp = new MaskedTextProvider (@\"" + mask.Replace ("\"", "\"\"") + "\");");
2075                                                                                 more_states = CreateState (mtp, stateindex);
2076                                                                                 stateindex++;
2077
2078                                                                                 WriteLine ("Assert.AreEqual ({0}, mtp.ToString ({4}, {5}, {6}, {2}, {3}), \"#{1}\");",
2079                                                                                         GetStringValue (mtp.ToString (value1, value2, value3, i, j)), (counter++).ToString (), i.ToString (), j.ToString (), value1 ? "true" : "false", value2 ? "true" : "false", value3 ? "true" : "false");
2080
2081                                                                                 WriteAssertProperties (mtp, Name, TestName, ref counter);
2082                                                                                 WriteTestEnd ();
2083
2084                                                                         } while (more_states);
2085                                                                 }
2086                                                         }
2087                                                 }
2088                                         }
2089                                 }
2090                         }
2091
2092                         WriteTestFooter ();
2093                 }
2094
2095                 static void GenerateVerifyCharTest ()
2096                 {
2097                         string Name = "mtp";
2098                         string TestName = MethodInfo.GetCurrentMethod ().Name.Replace ("Generate", "");
2099                         int counter = 0;
2100
2101                         WriteTestHeader (TestName, "MaskedTextProvider mtp;", "int Int32_out = 0;", "MaskedTextResultHint MaskedTextResultHint_out = MaskedTextResultHint.Unknown;");
2102                         MS_System_ComponentModel.MaskedTextProvider mtp = null;
2103                         //int Int32_out = 0;
2104                         MS_System_ComponentModel.MaskedTextResultHint MaskedTextResultHint_out = MS_System_ComponentModel.MaskedTextResultHint.Unknown;
2105
2106                         foreach (string mask in test_masks) {
2107                                 foreach (char str in char_values) {
2108                                         for (int i = -1; i < mask.Length + 1; i++) {
2109                                                 bool more_states = true;
2110                                                 int stateindex = 0;
2111                                                 do {
2112                                                         object [] arguments;
2113                                                         arguments = new object [] { str, i, MaskedTextResultHint_out };
2114                                                         if (Compare ("VerifyChar", mask, ref stateindex, arguments, ref more_states)) {
2115                                                                 continue;
2116                                                         }
2117
2118                                                         WriteTestStart ();
2119                                                         mtp = new MS_System_ComponentModel.MaskedTextProvider (mask);
2120                                                         WriteLine ("mtp = new MaskedTextProvider (@\"" + mask.Replace ("\"", "\"\"") + "\");");
2121                                                         more_states = CreateState (mtp, stateindex);
2122                                                         stateindex++;
2123
2124                                                         WriteLine ("Assert.AreEqual ({0}, mtp.VerifyChar ({1}, {2}, out MaskedTextResultHint_out), \"#{3}\");",
2125                                                                 GetStringValue (mtp.VerifyChar (str, i, out MaskedTextResultHint_out)), GetStringValue (str), i.ToString (), (counter++).ToString ());
2126                                                         WriteLine ("Assert.AreEqual ({0}, MaskedTextResultHint_out, \"#{1}\");", GetStringValue (MaskedTextResultHint_out), (counter++).ToString ());
2127
2128                                                         WriteAssertProperties (mtp, Name, TestName, ref counter);
2129                                                         WriteTestEnd ();
2130
2131                                                 } while (more_states);
2132                                         }
2133                                 }
2134                         }
2135
2136                         WriteTestFooter ();
2137                 }
2138                 static void GenerateVerifyEscapeCharTest ()
2139                 {
2140                         string Name = "mtp";
2141                         string TestName = MethodInfo.GetCurrentMethod ().Name.Replace ("Generate", "");
2142                         int counter = 0;
2143
2144                         WriteTestHeader (TestName, "MaskedTextProvider mtp;", "int Int32_out = 0;", "MaskedTextResultHint MaskedTextResultHint_out = MaskedTextResultHint.Unknown;");
2145                         MS_System_ComponentModel.MaskedTextProvider mtp = null;
2146                         //int Int32_out = 0;
2147                         //MS_System_ComponentModel.MaskedTextResultHint MaskedTextResultHint_out = MS_System_ComponentModel.MaskedTextResultHint.Unknown;
2148
2149                         foreach (string mask in test_masks) {
2150                                 foreach (char str in char_values) {
2151                                         for (int i = -1; i < mask.Length + 1; i++) {
2152                                                 bool more_states = true;
2153                                                 int stateindex = 0;
2154                                                 do {
2155                                                         object [] arguments;
2156                                                         arguments = new object [] { str, i };
2157                                                         if (Compare ("VerifyEscapeChar", mask, ref stateindex, arguments, ref more_states)) {
2158                                                                 continue;
2159                                                         }
2160
2161                                                         WriteTestStart ();
2162                                                         mtp = new MS_System_ComponentModel.MaskedTextProvider (mask);
2163                                                         WriteLine ("mtp = new MaskedTextProvider (@\"" + mask.Replace ("\"", "\"\"") + "\");");
2164                                                         more_states = CreateState (mtp, stateindex);
2165                                                         stateindex++;
2166
2167                                                         WriteLine ("Assert.AreEqual ({0}, mtp.VerifyEscapeChar ({1}, {2}), \"#{3}\");",
2168                                                                 GetStringValue (mtp.VerifyEscapeChar (str, i)), GetStringValue (str), i.ToString (), (counter++).ToString ());
2169
2170                                                         WriteAssertProperties (mtp, Name, TestName, ref counter);
2171                                                         WriteTestEnd ();
2172
2173                                                 } while (more_states);
2174                                         }
2175                                 }
2176                         }
2177
2178                         WriteTestFooter ();
2179                 }
2180                 static void GenerateVerifyString_string_Test ()
2181                 {
2182                         string Name = "mtp";
2183                         string TestName = MethodInfo.GetCurrentMethod ().Name.Replace ("Generate", "");
2184                         int counter = 0;
2185
2186                         WriteTestHeader (TestName, "MaskedTextProvider mtp;", "int Int32_out = 0;", "MaskedTextResultHint MaskedTextResultHint_out = MaskedTextResultHint.Unknown;");
2187                         MS_System_ComponentModel.MaskedTextProvider mtp = null;
2188                         //int Int32_out = 0;
2189                         //MS_System_ComponentModel.MaskedTextResultHint MaskedTextResultHint_out = MS_System_ComponentModel.MaskedTextResultHint.Unknown;
2190
2191                         foreach (string mask in test_masks) {
2192                                 foreach (string str in string_values) {
2193                                         bool more_states = true;
2194                                         int stateindex = 0;
2195                                         do {
2196                                                 object [] arguments;
2197                                                 arguments = new object [] { str };
2198                                                 if (Compare ("VerifyString", mask, ref stateindex, arguments, ref more_states)) {
2199                                                         continue;
2200                                                 }
2201
2202                                                 WriteTestStart ();
2203                                                 mtp = new MS_System_ComponentModel.MaskedTextProvider (mask);
2204                                                 WriteLine ("mtp = new MaskedTextProvider (@\"" + mask.Replace ("\"", "\"\"") + "\");");
2205                                                 more_states = CreateState (mtp, stateindex);
2206                                                 stateindex++;
2207
2208                                                 WriteLine ("Assert.AreEqual ({0}, mtp.VerifyString ({1}), \"#{2}\");",
2209                                                         GetStringValue (mtp.VerifyString (str)), GetStringValue (str), (counter++).ToString ());
2210
2211                                                 WriteAssertProperties (mtp, Name, TestName, ref counter);
2212                                                 WriteTestEnd ();
2213
2214                                         } while (more_states);
2215                                 }
2216                         }
2217
2218                         WriteTestFooter ();
2219                 }
2220                 static void GenerateVerifyString_string_int_MaskedTextResultHintTest ()
2221                 {
2222                         string Name = "mtp";
2223                         string TestName = MethodInfo.GetCurrentMethod ().Name.Replace ("Generate", "");
2224                         int counter = 0;
2225
2226                         WriteTestHeader (TestName, "MaskedTextProvider mtp;", "int Int32_out = 0;", "MaskedTextResultHint MaskedTextResultHint_out = MaskedTextResultHint.Unknown;");
2227                         MS_System_ComponentModel.MaskedTextProvider mtp = null;
2228                         int Int32_out = 0;
2229                         MS_System_ComponentModel.MaskedTextResultHint MaskedTextResultHint_out = MS_System_ComponentModel.MaskedTextResultHint.Unknown;
2230
2231                         foreach (string mask in test_masks) {
2232                                 foreach (string str in string_values) {
2233                                         bool more_states = true;
2234                                         int stateindex = 0;
2235                                         do {
2236                                                 object [] arguments;
2237                                                 arguments = new object [] { str, Int32_out, MaskedTextResultHint_out };
2238                                                 if (Compare ("VerifyString", mask, ref stateindex, arguments, ref more_states)) {
2239                                                         continue;
2240                                                 }
2241
2242                                                 WriteTestStart ();
2243                                                 mtp = new MS_System_ComponentModel.MaskedTextProvider (mask);
2244                                                 WriteLine ("mtp = new MaskedTextProvider (@\"" + mask.Replace ("\"", "\"\"") + "\");");
2245                                                 more_states = CreateState (mtp, stateindex);
2246                                                 stateindex++;
2247
2248                                                 WriteLine ("Assert.AreEqual ({0}, mtp.VerifyString ({1}, out Int32_out, out MaskedTextResultHint_out), \"#{2}\");",
2249                                                         GetStringValue (mtp.VerifyString (str, out Int32_out, out MaskedTextResultHint_out)), GetStringValue (str), (counter++).ToString ());
2250                                                 WriteLine ("Assert.AreEqual ({0}, MaskedTextResultHint_out, \"#{1}\");", GetStringValue (MaskedTextResultHint_out), (counter++).ToString ());
2251                                                 WriteLine ("Assert.AreEqual ({0}, Int32_out, \"#{1}\");", GetStringValue (Int32_out), (counter++).ToString ());
2252
2253                                                 WriteAssertProperties (mtp, Name, TestName, ref counter);
2254                                                 WriteTestEnd ();
2255                                         } while (more_states);
2256                                 }
2257                         }
2258
2259                         WriteTestFooter ();
2260                 }
2261
2262                 private static void CreateObjects (out object mtp_MS, out object mtp_Mono, string mask)
2263                 {
2264                         if (type_MS == null) {
2265                                 type_MS = Assembly.Load ("System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089").GetType ("System.ComponentModel.MaskedTextProvider");
2266                                 type_Hint_MS = Assembly.Load ("System, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089").GetType ("System.ComponentModel.MaskedTextResultHint");
2267                         }
2268                         if (type_Mono == null) {
2269                                 type_Mono = Assembly.GetExecutingAssembly ().GetType ("System.ComponentModel.MaskedTextProvider");
2270                                 type_Hint_Mono = Assembly.GetExecutingAssembly ().GetType ("System.ComponentModel.MaskedTextResultHint");
2271                         }
2272
2273                         if (type_MS == null) {
2274                                 Assert.Ignore ("Could not load MS' version of MaskedTextProvider.");
2275                         }
2276                         if (type_Mono == null) {
2277                                 Assert.Ignore ("Could not load Mono's version of MaskedTextProvider.");
2278                         }
2279                         if (type_Mono == type_MS) {
2280                                 Assert.Ignore ("You're running on the Mono runtime, this test can only be run on the MS runtime.");
2281                         }
2282
2283                         mtp_Mono = type_Mono.GetConstructor (new Type [] { typeof (string) }).Invoke (new object [] { mask });
2284                         mtp_MS = type_MS.GetConstructor (new Type [] { typeof (string) }).Invoke (new object [] { mask });
2285                 }
2286
2287                 // Gets the mtp into a certain state.
2288                 // returns false if index+1 is not valid.
2289                 // index starts at 0.
2290                 static bool CreateState (object mtp, int index)
2291                 {
2292                         object [] states = (object [])state_methods_values [index];
2293                         for (int j = 0; j < states.Length; j++) {
2294                                 object [] state = (object [])states [j];
2295                                 string name = (string)state [0];
2296                                 object [] args = (object [])state [1];
2297                                 Type [] arg_types = new Type [args.Length];
2298                                 for (int i = 0; i < args.Length; i++) {
2299                                         arg_types [i] = args [i].GetType ();
2300                                 }
2301                                 MethodInfo method = mtp.GetType ().GetMethod (name, arg_types);
2302                                 if (method == null) {
2303                                         if (arg_types [arg_types.Length - 1].Name == "MaskedTextResultHint") {
2304                                                 arg_types [arg_types.Length - 1] = arg_types [arg_types.Length - 1].MakeByRefType ();
2305                                                 arg_types [arg_types.Length - 2] = arg_types [arg_types.Length - 2].MakeByRefType ();
2306                                                 args [arg_types.Length - 1] = (int)args [arg_types.Length - 1];
2307                                                 method = mtp.GetType ().GetMethod (name, arg_types);
2308                                                 args [arg_types.Length - 1] = Enum.ToObject (method.GetParameters () [arg_types.Length - 1].ParameterType.GetElementType (), (int)args [arg_types.Length - 1]);
2309                                         }
2310                                 }
2311                                 if (method == null)
2312                                         Console.WriteLine ("STOP");
2313                                 method.Invoke (mtp, args);
2314                                 string line;
2315                                 line = "mtp." + method.Name + "(";
2316                                 for (int i = 0; i < args.Length; i++) {
2317                                         if (arg_types [i].IsByRef) {
2318                                                 line += "out " + arg_types [i].GetElementType ().Name + "_out";
2319                                         } else {
2320                                                 line += GetStringValue (args [i]);
2321                                         }
2322                                         if (i < args.Length - 1)
2323                                                 line += ", ";
2324                                 }
2325                                 line += ");";
2326                                 WriteLine (line);
2327                         }
2328                         if (state_methods_values.Length <= index + 1)
2329                                 return false;
2330                         return true;
2331                 }
2332
2333                 static void WriteLineNonFormat (string msg)
2334                 {
2335                         if (dont_write)
2336                                 return;
2337
2338                         writer.WriteLine (tabs + msg);
2339                 }
2340                 static void WriteLine (string msg, params string [] args)
2341                 {
2342                         if (dont_write)
2343                                 return;
2344                         writer.WriteLine (tabs + msg, args);
2345                 }
2346
2347                 static string tabs
2348                 {
2349                         get
2350                         {
2351                                 return new string ('\t', tab);
2352                         }
2353                 }
2354
2355                 static Array GetTestValues (Type tp)
2356                 {
2357                         if (tp == typeof (char)) {
2358                                 return char_values;
2359                         } else if (tp == typeof (int) || tp == typeof (int).MakeByRefType ()) {
2360                                 return int_values;
2361                         } else if (tp == typeof (string)) {
2362                                 return string_values;
2363                         } else if (tp == typeof (CultureInfo)) {
2364                                 return culture_infos;
2365                         } else if (tp == typeof (bool)) {
2366                                 return new bool [] { true, false };
2367                         } else if (tp == typeof (MaskedTextResultHint) || tp == typeof (MaskedTextResultHint).MakeByRefType ()) {
2368                                 return hint_values;
2369                         } else if (tp == typeof (object)) {
2370                                 return object_values;
2371                         } else {
2372                                 throw new NotImplementedException ();
2373                         }
2374                 }
2375
2376                 static string GetStringValue (object obj)
2377                 {
2378                         if (obj == null)
2379                                 return "null";
2380
2381                         Type tp = obj.GetType ();
2382
2383                         if (tp == typeof (char)) {
2384                                 return string.Format ("'\\x{0:X}'", Convert.ToInt32 ((char)obj));
2385                         } else if (tp == typeof (int)) {
2386                                 return obj.ToString ();
2387                         } else if (tp == typeof (string)) {
2388                                 return "@\"" + obj.ToString ().Replace ("\"", "\"\"") + "\"";
2389                         } else if (tp == typeof (CultureInfo)) {
2390                                 CultureInfo ci = (CultureInfo)obj;
2391                                 //return "\"" + ci.Name + "\"";
2392                                 return "CultureInfo.GetCultureInfo (\"" + ci.Name + "\")";
2393                         } else if (tp == typeof (bool)) {
2394                                 return ((bool)obj) ? "true" : "false";
2395                         } else if (tp == typeof (MaskedTextProvider)) {
2396                                 return "@\"" + obj.ToString ().Replace ("\"", "\"\"") + "\"";
2397                         } else if (tp is IEnumerator) {
2398                                 return "@\"" + obj.ToString ().Replace ("\"", "\"\"") + "\"";
2399                         } else if (tp == typeof (List<int>.Enumerator)) {
2400                                 return "@\"" + obj.ToString ().Replace ("\"", "\"\"") + "\"";
2401                         } else if (tp.Name == "MaskedTextResultHint") {
2402                                 return "MaskedTextResultHint." + obj.ToString ();
2403                         } else if (tp is Type) {
2404                                 return "typeof (" + ((Type)obj).FullName + ")";
2405                         } else {
2406                                 throw new NotImplementedException ();
2407                         }
2408                 }
2409
2410                 static bool IncIndex (int [] indices, Array [] inputs)
2411                 {
2412                         for (int i = indices.Length - 1; i >= 0; i--) {
2413                                 if (indices [i] >= inputs [i].Length - 1) {
2414                                         if (i == 0) {
2415                                                 return false;
2416                                         }
2417                                         indices [i] = 0;
2418                                         indices [i - 1]++;
2419
2420                                         int a, b;
2421                                         a = indices [i - 1];
2422                                         b = inputs [i - 1].Length - 1;
2423                                         if (a < b) {
2424                                                 return true;
2425                                         }
2426
2427                                 } else {
2428                                         indices [i]++;
2429                                         return true;
2430                                 }
2431                         }
2432                         return false;
2433                 }
2434
2435                 static string GetTestName (string prefix, ParameterInfo [] ps)
2436                 {
2437                         string result = prefix;
2438                         for (int b = 0; b < ps.Length; b++)
2439                                 result += "_" + ps [b].ParameterType.Name.Replace ("&", "").Replace ("+", "").Replace ("*", "");
2440                         result += "_Test";
2441                         return result;
2442
2443                 }
2444
2445                 //static void MethodsTest ()
2446                 //{
2447                 //        string Name = "mtp";
2448                 //        int counter = 0;
2449                 //        MS_System_ComponentModel.MaskedTextProvider mtp = null;
2450
2451                 //        for (int a = 0; a < methods.Length; a++) {
2452                 //                MethodInfo method = methods [a];
2453
2454                 //                if (method.Name.StartsWith ("get_") || method.Name.StartsWith ("set_"))
2455                 //                        continue;
2456                 //                if (method.IsStatic)
2457                 //                        continue;
2458
2459                 //                ParameterInfo [] ps = method.GetParameters ();
2460                 //                Array [] inputs = new Array [ps.Length];
2461                 //                int [] indices = new int [ps.Length];
2462
2463                 //                string TestName = GetTestName (method.Name, ps);
2464
2465                 //                Console.WriteLine ("Method (" + (a + 1).ToString () + "/" + methods.Length.ToString () + "): " + TestName);
2466
2467                 //                int assert_count = 1;
2468                 //                WriteTestHeader (TestName);
2469                 //                WriteLine ("MaskedTextProvider mtp;");
2470                 //                WriteLine ("object result = null;");
2471
2472
2473                 //                for (int i = 0; i < ps.Length; i++)
2474                 //                        inputs [i] = GetTestValues (ps [i].ParameterType);
2475
2476                 //                foreach (string mask in test_masks) {
2477                 //                        do {
2478                 //                                Exception ex = null;
2479                 //                                object result = null;
2480
2481                 //                                object [] args = new object [inputs.Length];
2482                 //                                for (int i = 0; i < inputs.Length; i++) {
2483                 //                                        args [i] = inputs [i].GetValue (indices [i]);
2484                 //                                }
2485
2486                 //                                mtp = new MS_System_ComponentModel.MaskedTextProvider (mask);
2487                 //                                WriteLine ("mtp = new MaskedTextProvider (@\"{0}\");", mask.Replace ("\"", "\"\""));
2488
2489                 //                                try {
2490                 //                                        result = method.Invoke (mtp, args);
2491                 //                                } catch (TargetInvocationException e) {
2492                 //                                        ex = e.InnerException;
2493                 //                                } catch (Exception e) {
2494                 //                                        ex = e;
2495                 //                                }
2496
2497                 //                                WriteLine ("");
2498                 //                                WriteLine ("try {");
2499                 //                                tab++;
2500                 //                                string tmp = "";
2501                 //                                for (int j = 0; j < args.Length; j++) {
2502                 //                                        bool tmpvar = false;
2503                 //                                        if (tmp != "")
2504                 //                                                tmp += ", ";
2505                 //                                        //if (ps [j].ParameterType.IsByRef) {
2506                 //                                        //        tmp += "ref ";
2507                 //                                        //        tmpvar = true;
2508                 //                                        //}
2509                 //                                        if (ps [j].IsOut) {
2510                 //                                                tmp += "out ";
2511                 //                                                tmpvar = true;
2512                 //                                        }
2513                 //                                        if (tmpvar) {
2514                 //                                                string name = "tmpvar_" + (counter++).ToString ();
2515                 //                                                WriteLine (ps [j].ParameterType.GetElementType ().Name + " " + name + " = " + GetStringValue (args [j]) + ";");
2516                 //                                                tmp += name;
2517                 //                                        } else {
2518                 //                                                tmp += GetStringValue (args [j]);
2519                 //                                        }
2520                 //                                }
2521                 //                                string statement;
2522                 //                                bool is_void = !(method.ReturnType == null || method.ReturnType == typeof (void));
2523                 //                                statement = "mtp." + method.Name + " (" + tmp + ");";
2524                 //                                if (is_void) {
2525                 //                                        statement = "result = " + statement;
2526                 //                                }
2527                 //                                WriteLine (statement);
2528
2529                 //                                if (ex != null) {
2530                 //                                        WriteLine ("Assert.Fail (\"Expected '{0}'\");", ex.GetType ().FullName);
2531                 //                                } else {
2532                 //                                        WriteAssertProperties (mtp, Name, TestName, ref assert_count);
2533                 //                                        if (!is_void)
2534                 //                                                WriteLine ("Assert.AreEqual ({0}, result, \"{1}#{2}\");", GetStringValue (result), TestName, (assert_count++).ToString ());
2535                 //                                }
2536                 //                                tab--;
2537                 //                                WriteLine ("} catch (Exception ex) {");
2538                 //                                tab++;
2539                 //                                if (ex == null) {
2540                 //                                        WriteLine ("Assert.Fail (\"Unexpected exception of Type = \" + ex.GetType ().FullName + \", Message = \" + ex.Message + \".\");");
2541                 //                                } else {
2542                 //                                        WriteLine ("Assert.AreEqual (\"{0}\", ex.GetType ().FullName, \"{1}#{2}\");", ex.GetType ().FullName, TestName, (assert_count++).ToString ());
2543                 //                                        WriteLine ("Assert.AreEqual (@\"{0}\", ex.Message, \"{1}#{2}\");", ex.Message.Replace ("\"", "\"\""), TestName, (assert_count++).ToString ());
2544                 //                                }
2545                 //                                tab--;
2546                 //                                WriteLine ("}");
2547
2548                 //                        } while (IncIndex (indices, inputs));
2549                 //                        WriteLine ("");
2550                 //                }
2551                 //                WriteTestFooter ();
2552                 //        }
2553
2554                 //}
2555
2556                 //static void ConstructorTest ()
2557                 //{
2558                 //        int assert_count = 1;
2559                 //        string Name = "mtp";
2560
2561
2562                 //        foreach (ConstructorInfo ctor in ctors) {
2563                 //                string TestName = GetTestName ("Constructor", ctor.GetParameters ());
2564
2565                 //                WriteTestHeader (TestName);
2566                 //                MS_System_ComponentModel.MaskedTextProvider mtp = null;
2567                 //                WriteLine ("MaskedTextProvider mtp;");
2568
2569                 //                ParameterInfo [] ps = ctor.GetParameters ();
2570                 //                Array [] inputs = new Array [ps.Length];
2571                 //                int [] indices = new int [ps.Length];
2572
2573                 //                for (int i = 0; i < ps.Length; i++)
2574                 //                        inputs [i] = GetTestValues (ps [i].ParameterType);
2575
2576                 //                do {
2577                 //                        object [] args = new object [inputs.Length];
2578                 //                        for (int i = 0; i < inputs.Length; i++) {
2579                 //                                args [i] = inputs [i].GetValue (indices [i]);
2580                 //                        }
2581
2582                 //                        Exception ex = null;
2583                 //                        mtp = null;
2584                 //                        try {
2585                 //                                mtp = (MS_System_ComponentModel.MaskedTextProvider)ctor.Invoke (args);
2586                 //                        } catch (TargetInvocationException e) {
2587                 //                                ex = e.InnerException;
2588                 //                        } catch (Exception e) {
2589                 //                                ex = e;
2590                 //                        }
2591
2592                 //                        WriteLine ("");
2593                 //                        WriteLine ("try {");
2594                 //                        tab++;
2595                 //                        string tmp = "";
2596                 //                        for (int j = 0; j < args.Length; j++) {
2597                 //                                if (tmp != "")
2598                 //                                        tmp += ", ";
2599                 //                                tmp += GetStringValue (args [j]);
2600                 //                        }
2601
2602                 //                        string statement;
2603                 //                        statement = "mtp = new MaskedTextProvider (" + tmp + ");";
2604                 //                        WriteLine (statement);
2605                 //                        if (ex == null) {
2606                 //                                ok_constructors.Add (ctor);
2607                 //                                ok_constructors_args.Add (args);
2608                 //                                ok_constructors_statements.Add (statement);
2609                 //                        }
2610
2611                 //                        if (ex != null) {
2612                 //                                WriteLine ("Assert.Fail (\"Expected '{0}'\");", ex.GetType ().FullName);
2613                 //                        } else {
2614                 //                                WriteAssertProperties (mtp, Name, TestName, ref assert_count);
2615                 //                        }
2616                 //                        tab--;
2617                 //                        WriteLine ("} catch (Exception ex) {");
2618                 //                        tab++;
2619                 //                        if (ex == null) {
2620                 //                                WriteLine ("Assert.Fail (\"Unexpected exception of Type = \" + ex.GetType ().FullName + \", Message = \" + ex.Message + \".\");");
2621                 //                        } else {
2622                 //                                WriteLine ("Assert.AreEqual (\"{0}\", ex.GetType ().FullName, \"{1}#{2}\");", ex.GetType ().FullName, TestName, (assert_count++).ToString ());
2623                 //                                WriteLine ("Assert.AreEqual (@\"{0}\", ex.Message, \"{1}#{2}\");", ex.Message.Replace ("\"", "\"\""), TestName, (assert_count++).ToString ());
2624                 //                        }
2625                 //                        tab--;
2626                 //                        WriteLine ("}");
2627
2628                 //                } while (IncIndex (indices, inputs));
2629                 //                WriteTestFooter ();
2630                 //        }
2631
2632                 //}
2633
2634                 static string current_test_name;
2635                 static int current_test_counter;
2636                 static int skipped_test_counter;
2637                 static int total_skipped_counter;
2638                 static int total_test_counter;
2639                 static string [] current_test_method_init;
2640                 static void WriteTestHeader (string TestName, params string [] method_init)
2641                 {
2642                         //WriteLine ("[Test]");
2643                         //WriteLine ("public void " + TestName  + " ()");
2644                         WriteLineNonFormat ("[TestFixture]");
2645                         WriteLineNonFormat ("public class " + TestName);
2646                         WriteLineNonFormat ("{");
2647                         tab++;
2648                         total_test_counter += current_test_counter;
2649                         current_test_counter = 0;
2650                         total_skipped_counter += skipped_test_counter;
2651                         skipped_test_counter = 0;
2652                         current_test_name = TestName;
2653                         current_test_method_init = method_init;
2654                         Console.Write ("Writing " + TestName + "... ");
2655                 }
2656                 static void WriteTestFooter ()
2657                 {
2658                         tab--;
2659                         WriteLineNonFormat ("}");
2660                         Console.WriteLine ("written " + (current_test_counter - skipped_test_counter).ToString () + " tests, and skipped " + skipped_test_counter.ToString () + " tests.");
2661                         dont_write = false;
2662                 }
2663                 static void WriteTestStart ()
2664                 {
2665                         current_test_counter++;
2666
2667                         WriteLineNonFormat ("[Test]");
2668                         WriteLineNonFormat ("public void " + current_test_name + current_test_counter.ToString ("00000") + " ()");
2669                         WriteLineNonFormat ("{");
2670                         tab++;
2671                         foreach (string str in current_test_method_init)
2672                                 WriteLine (str);
2673                 }
2674                 static void WriteTestEnd ()
2675                 {
2676                         tab--;
2677                         WriteLineNonFormat ("}");
2678                 }
2679                 static void WriteFileHeader ()
2680                 {
2681                         WriteLineNonFormat (
2682 @"//
2683 // System.ComponentModel.MaskedTextProvider generated test cases
2684 //
2685 // Authors:
2686 //      Rolf Bjarne Kvinge (RKvinge@novell.com)
2687 //
2688 // (c) 2007 Novell
2689 //
2690
2691 using System;
2692 using System.ComponentModel;
2693 using System.Drawing.Design;
2694 using System.Globalization;
2695 using System.Collections;
2696 using NUnit.Framework;
2697
2698 namespace MonoTests.System.ComponentModel
2699 {
2700         [TestFixture]
2701         public class MaskedTextProviderGeneratedTests
2702         {
2703 ");
2704
2705                         tab += 2;
2706                 }
2707                 static void WriteFileFooter ()
2708                 {
2709                         WriteLineNonFormat (
2710 @"
2711         }
2712 }
2713 ");
2714                         tab -= 2;
2715                         Console.WriteLine ("Written " + (total_test_counter - total_skipped_counter).ToString () + " tests in total and skipped " + total_skipped_counter.ToString () + " tests.");
2716                 }
2717
2718                 //static void WriteAssertProperties (MaskedTextProvider mtp, string Name, string TestName, ref int i)
2719                 //{
2720                 //        WriteLine ("// Testing all properties...");
2721                 //        //return;
2722                 //        WriteLine ("Assert.AreEqual ({0}, {1}.AllowPromptAsInput, \"{2}-#{3}\");", GetStringValue (mtp.AllowPromptAsInput), Name, TestName, (i++).ToString ());
2723                 //        WriteLine ("Assert.AreEqual ({0}, {1}.AsciiOnly, \"{2}-#{3}\");", GetStringValue (mtp.AsciiOnly), Name, TestName, (i++).ToString ());
2724                 //        WriteLine ("Assert.AreEqual ({0}, {1}.AssignedEditPositionCount, \"{2}-#{3}\");", GetStringValue (mtp.AssignedEditPositionCount), Name, TestName, (i++).ToString ());
2725                 //        WriteLine ("Assert.AreEqual ({0}, {1}.AvailableEditPositionCount, \"{2}-#{3}\");", GetStringValue (mtp.AvailableEditPositionCount), Name, TestName, (i++).ToString ());
2726                 //        WriteLine ("Assert.AreEqual ({0}, {1}.Culture, \"{2}-#{3}\");", GetStringValue (mtp.Culture), Name, TestName, (i++).ToString ());
2727                 //        WriteLine ("Assert.AreEqual ({0}, {1}.EditPositionCount, \"{2}-#{3}\");", GetStringValue (mtp.EditPositionCount), Name, TestName, (i++).ToString ());
2728                 //        //WriteLine ("Assert.AreEqual ({0}, {1}.EditPositions, \"{2}-#{3}\");", GetStringValue (mtp.EditPositions), Name, TestName, (i++).ToString ());
2729                 //        WriteLine ("Assert.AreEqual ({0}, {1}.IncludeLiterals, \"{2}-#{3}\");", GetStringValue (mtp.IncludeLiterals), Name, TestName, (i++).ToString ());
2730                 //        WriteLine ("Assert.AreEqual ({0}, {1}.IncludePrompt, \"{2}-#{3}\");", GetStringValue (mtp.IncludePrompt), Name, TestName, (i++).ToString ());
2731                 //        WriteLine ("Assert.AreEqual ({0}, {1}.IsPassword, \"{2}-#{3}\");", GetStringValue (mtp.IsPassword), Name, TestName, (i++).ToString ());
2732                 //        WriteLine ("Assert.AreEqual ({0}, {1}.LastAssignedPosition, \"{2}-#{3}\");", GetStringValue (mtp.LastAssignedPosition), Name, TestName, (i++).ToString ());
2733                 //        WriteLine ("Assert.AreEqual ({0}, {1}.Length, \"{2}-#{3}\");", GetStringValue (mtp.Length), Name, TestName, (i++).ToString ());
2734                 //        WriteLine ("Assert.AreEqual ({0}, {1}.Mask, \"{2}-#{3}\");", GetStringValue (mtp.Mask), Name, TestName, (i++).ToString ());
2735                 //        WriteLine ("Assert.AreEqual ({0}, {1}.MaskCompleted, \"{2}-#{3}\");", GetStringValue (mtp.MaskCompleted), Name, TestName, (i++).ToString ());
2736                 //        WriteLine ("Assert.AreEqual ({0}, {1}.MaskFull, \"{2}-#{3}\");", GetStringValue (mtp.MaskFull), Name, TestName, (i++).ToString ());
2737                 //        WriteLine ("Assert.AreEqual ({0}, {1}.PasswordChar, \"{2}-#{3}\");", GetStringValue (mtp.PasswordChar), Name, TestName, (i++).ToString ());
2738                 //        WriteLine ("Assert.AreEqual ({0}, {1}.PromptChar, \"{2}-#{3}\");",GetStringValue ( mtp.PromptChar), Name, TestName, (i++).ToString ());
2739                 //        WriteLine ("Assert.AreEqual ({0}, {1}.ResetOnPrompt, \"{2}-#{3}\");", GetStringValue (mtp.ResetOnPrompt), Name, TestName, (i++).ToString ());
2740                 //        WriteLine ("Assert.AreEqual ({0}, {1}.ResetOnSpace, \"{2}-#{3}\");", GetStringValue (mtp.ResetOnSpace), Name, TestName, (i++).ToString ());
2741                 //        WriteLine ("Assert.AreEqual ({0}, {1}.SkipLiterals, \"{2}-#{3}\");", GetStringValue (mtp.SkipLiterals), Name, TestName, (i++).ToString ());
2742                 //}
2743
2744
2745                 static bool CompareMaskTextProviders (object mtp_MS, object mtp_Mono)
2746                 {
2747                         object value_ms, value_mono;
2748                         PropertyInfo [] fields = mtp_MS.GetType ().GetProperties (BindingFlags.Public | BindingFlags.Instance | BindingFlags.GetProperty);
2749                         foreach (PropertyInfo field_MS in fields) {
2750                                 if (field_MS.Name == "EditPositions")
2751                                         continue;
2752                                 if (field_MS.Name == "Culture")
2753                                         continue;
2754                                 if (field_MS.Name == "Item")
2755                                         continue;
2756
2757                                 PropertyInfo field_Mono = mtp_Mono.GetType ().GetProperty (field_MS.Name);
2758
2759                                 value_ms = field_MS.GetValue (mtp_MS, null);
2760                                 value_mono = field_Mono.GetValue (mtp_Mono, null);
2761
2762                                 if (!Compare (value_ms, value_mono)) {
2763                                         return false;
2764                                 }
2765                         }
2766
2767                         MethodInfo method_MS, method_Mono;
2768                         string name;
2769                         Type [] args;
2770                         object [] all_values = new object [] {
2771                                 new object [] {},
2772                                 new object [] {true},
2773                                 new object [] {false},
2774                                 new object [] {true, true},
2775                                 new object [] {false, true},
2776                                 new object [] {true, false},
2777                                 new object [] {false, false},
2778                         };
2779
2780                         name = "ToString";
2781                         foreach (object [] values in all_values) {
2782                                 args = new Type [values.Length];
2783                                 for (int i = 0; i < values.Length; i++) {
2784                                         args [i] = values [i].GetType ();
2785                                 }
2786                                 method_Mono = mtp_Mono.GetType ().GetMethod (name, args);
2787                                 method_MS = mtp_MS.GetType ().GetMethod (name, args);
2788                                 value_ms = method_MS.Invoke (mtp_MS, values);
2789                                 value_mono = method_Mono.Invoke (mtp_Mono, values);
2790                                 if (!Compare (value_ms, value_mono)) {
2791                                         return false;
2792                                 }
2793                         }
2794
2795                         return true;
2796                 }
2797
2798                 static bool Compare (object v1, object v2)
2799                 {
2800                         if (v1 == null && v2 == null) {
2801                                 return true;
2802                         } else if (v1 == null ^ v2 == null) {
2803                                 return false;
2804                         } else if (v1.GetType ().Name == "MaskedTextResultHint" && v2.GetType ().Name == "MaskedTextResultHint") {
2805                                 return (int)v1 == (int)v2;
2806                         } else if (v1.GetType ().FullName == "System.Collections.Generic.List`1+Enumerator[[System.Int32, mscorlib, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089]]" && v2.GetType ().FullName == v1.GetType ().FullName) {
2807                                 List <int>.Enumerator list1, list2;
2808                                 list1 = (List<int>.Enumerator) v1;
2809                                 list2 = (List<int>.Enumerator) v2;
2810                                 int item1, item2;
2811                                 bool next1, next2;
2812                                 do {
2813                                         next1 = list1.MoveNext ();
2814                                         next2 = list2.MoveNext ();
2815                                         if (next1 ^ next2) {
2816                                                 return false;
2817                                         }
2818                                         if (!next1 && !next2) {
2819                                                 return true;
2820                                         }
2821                                         item1 = list1.Current;
2822                                         item2 = list2.Current;
2823                                         if (item1 != item2) {
2824                                                 return false;
2825                                         }
2826                                 } while (true);
2827                         } else if (!v1.Equals (v2)) {
2828                                 return false;
2829                         } else {
2830                                 return true;
2831                         }
2832                 }
2833                 static bool Compare (string methodName, string mask, ref int stateindex, object [] args, ref bool more_states)
2834                 {
2835                         //if (!new StackFrame (1).GetMethod ().Name.Contains (methodName) && !new StackFrame (2).GetMethod ().Name.Contains (methodName)) {
2836                         //        Console.WriteLine ("STOP");
2837                         //        Console.Read ();
2838                         //}
2839
2840                         bool result = false;
2841
2842                         try {
2843                                 if ((current_test_counter - skipped_test_counter) > MAXFAILEDTESTS) {
2844                                         more_states = false;
2845                                         return true;
2846                                 }
2847
2848                                 object [] args_MS, args_Mono;
2849                                 object mtp_MS, mtp_Mono;
2850                                 dont_write = true;
2851
2852                                 args_MS = new object [args.Length];
2853                                 args_Mono = new object [args.Length];
2854
2855                                 CreateObjects (out mtp_MS, out mtp_Mono, mask);
2856
2857                                 for (int i = 0; i < args.Length; i++) {
2858                                         if (args [i] != null && args [i].GetType ().Name == "MaskedTextResultHint") {
2859                                                 args_Mono [i] = Enum.ToObject (type_Hint_Mono, (int)args [i]);
2860                                                 args_MS [i] = Enum.ToObject (type_Hint_MS, (int)args [i]);
2861                                         } else {
2862                                                 args_Mono [i] = args [i];
2863                                                 args_MS [i] = args [i];
2864                                         }
2865                                 }
2866
2867                                 more_states = CreateState (mtp_MS, stateindex);
2868                                 more_states = CreateState (mtp_Mono, stateindex);
2869
2870                                 if (mtp_MS.GetType ().GetProperty (methodName) != null) {
2871                                         methodName = "get_" + methodName;
2872                                 }
2873                                 object result_MS, result_Mono;
2874                                 result_MS = mtp_MS.GetType ().InvokeMember (methodName, BindingFlags.Public | BindingFlags.Instance | BindingFlags.InvokeMethod, null, mtp_MS, args_MS);
2875                                 result_Mono = mtp_Mono.GetType ().InvokeMember (methodName, BindingFlags.Public | BindingFlags.Instance | BindingFlags.InvokeMethod, null, mtp_Mono, args_Mono);
2876
2877                                 result = true;
2878                                 for (int arg = 0; arg < args_Mono.Length; arg++) {
2879                                         if (!Compare (args_MS [arg], args_Mono [arg])) {
2880                                                 result = false;
2881                                                 break;
2882                                         }
2883                                 }
2884                                 if (result && !CompareMaskTextProviders (mtp_MS, mtp_Mono)) {
2885                                         result = false;
2886                                 }
2887                                 if (result && !Compare (result_MS, result_Mono)) {
2888                                         result = false;
2889                                 }
2890                         } catch (Exception ex) {
2891                                 result = false;
2892                                 more_states = false;
2893                                 Console.WriteLine (ex.Message);
2894                         } finally {
2895                                 dont_write = false;
2896
2897                                 if (result) {
2898                                         current_test_counter++;
2899                                         skipped_test_counter++;
2900                                         stateindex++;
2901                                 }
2902                         }
2903                         return result;
2904                 }
2905
2906                 static void WriteAssertPropertiesMethod ()
2907                 {
2908                         string filecontents = File.ReadAllText (Path.Combine (Path.GetDirectoryName (Path.GetFullPath (destination_file)), "MaskedTextProviderTest.cs"));
2909                         string method;
2910                         int start, end;
2911                         start = filecontents.IndexOf ("/*" + " START */"); // strings are split in two so to not match itself.
2912                         end = filecontents.IndexOf ("/*" + " END */");
2913                         method = filecontents.Substring (start + 11, end - start - 11);
2914                         WriteLineNonFormat (method.Replace ("{", "{").Replace ("}", "}"));
2915
2916                         //public static void AssertProperties (MaskedTextProvider mtp, string test_name, int counter, bool allow_prompt, bool ascii_only, int assigned_edit_position_count, int available_edit_position_count,
2917                         //                CultureInfo culture, int edit_position_count, bool include_literals, bool include_prompt, bool is_password, int last_assigned_position,
2918                         //                int length, string mask, bool mask_completed, bool mask_full, char password_char, char prompt_char, bool reset_on_prompt, bool reset_on_space, bool skip_literals,
2919                         //                string tostring, string tostring_true, string tostring_false, string tostring_true_true, string tostring_true_false, string tostring_false_true, string tostring_false_false)
2920                         //                {
2921                         //                // Testing all properties...
2922                         //                //return;
2923                         //                int i = 1;
2924                         //                Assert.AreEqual (allow_prompt, mtp.AllowPromptAsInput, string.Format(""{0}-#{1} (AllowPromptAsInput)"", test_name + counter.ToString (), (i++).ToString ()));
2925                         //                Assert.AreEqual (ascii_only, mtp.AsciiOnly, string.Format(""{0}-#{1} (AsciiOnly)"", test_name + counter.ToString (), (i++).ToString ()));
2926                         //                Assert.AreEqual (assigned_edit_position_count, mtp.AssignedEditPositionCount, string.Format(""{0}-#{1} (AssignedEditPositionCount)"", test_name + counter.ToString (), (i++).ToString ()));
2927                         //                Assert.AreEqual (available_edit_position_count, mtp.AvailableEditPositionCount, string.Format(""{0}-#{1} (AvailableEditPositionCount)"", test_name + counter.ToString (), (i++).ToString ()));
2928                         //                Assert.AreEqual (culture, mtp.Culture, string.Format(""{0}-#{1} (Culture)"", test_name + counter.ToString (), (i++).ToString ()));
2929                         //                Assert.AreEqual (edit_position_count, mtp.EditPositionCount, string.Format(""{0}-#{1} (EditPositionCount)"", test_name + counter.ToString (), (i++).ToString ()));
2930                         //                //Assert.AreEqual ({0}, mtp.EditPositions,string.Format( ""{0}-#{1} (EditPositions)"", test_name + counter.ToString (), (i++).ToString ()));
2931                         //                Assert.AreEqual (include_literals, mtp.IncludeLiterals, string.Format(""{0}-#{1} (IncludeLiterals)"", test_name + counter.ToString (), (i++).ToString ()));
2932                         //                Assert.AreEqual (include_prompt, mtp.IncludePrompt, string.Format(""{0}-#{1} (IncludePrompt)"", test_name + counter.ToString (), (i++).ToString ()));
2933                         //                Assert.AreEqual (is_password, mtp.IsPassword, string.Format(""{0}-#{1} (IsPassword)"", test_name + counter.ToString (), (i++).ToString ()));
2934                         //                Assert.AreEqual (last_assigned_position, mtp.LastAssignedPosition, string.Format(""{0}-#{1} (LastAssignedPosition)"", test_name + counter.ToString (), (i++).ToString ()));
2935                         //                Assert.AreEqual (length, mtp.Length, string.Format(""{0}-#{1} (Length)"", test_name + counter.ToString (), (i++).ToString ()));
2936                         //                Assert.AreEqual (mask, mtp.Mask, string.Format(""{0}-#{1} (Mask)"", test_name + counter.ToString (), (i++).ToString ()));
2937                         //                Assert.AreEqual (mask_completed, mtp.MaskCompleted, string.Format(""{0}-#{1} (MaskCompleted)"", test_name + counter.ToString (), (i++).ToString ()));
2938                         //                Assert.AreEqual (mask_full, mtp.MaskFull, string.Format(""{0}-#{1} (MaskFull)"", test_name + counter.ToString (), (i++).ToString ()));
2939                         //                Assert.AreEqual (password_char, mtp.PasswordChar, string.Format(""{0}-#{1} (PasswordChar)"", test_name + counter.ToString (), (i++).ToString ()));
2940                         //                Assert.AreEqual (prompt_char, mtp.PromptChar, string.Format(""{0}-#{1} (PromptChar)"", test_name + counter.ToString (), (i++).ToString ()));
2941                         //                Assert.AreEqual (reset_on_prompt, mtp.ResetOnPrompt, string.Format(""{0}-#{1} (ResetOnPrompt)"", test_name + counter.ToString (), (i++).ToString ()));
2942                         //                Assert.AreEqual (reset_on_space, mtp.ResetOnSpace, string.Format(""{0}-#{1} (ResetOnSpace)"", test_name + counter.ToString (), (i++).ToString ()));
2943                         //                Assert.AreEqual (skip_literals, mtp.SkipLiterals, string.Format(""{0}-#{1} (SkipLiterals)"", test_name + counter.ToString (), (i++).ToString ()));
2944                         //                Assert.AreEqual (tostring, mtp.ToString (), string.Format(""{0}-#{1} (tostring)"", test_name + counter.ToString (), (i++).ToString ()));
2945                         //                Assert.AreEqual (tostring_true, mtp.ToString (true), string.Format(""{0}-#{1} (tostring_true)"", test_name + counter.ToString (), (i++).ToString ()));
2946                         //                Assert.AreEqual (tostring_false, mtp.ToString (false), string.Format(""{0}-#{1} (tostring_false)"", test_name + counter.ToString (), (i++).ToString ()));
2947                         //                Assert.AreEqual (tostring_true_true, mtp.ToString (true, true), string.Format(""{0}-#{1} (tostring_true_true)"", test_name + counter.ToString (), (i++).ToString ()));
2948                         //                Assert.AreEqual (tostring_true_false, mtp.ToString (true, false), string.Format(""{0}-#{1} (tostring_true_false)"", test_name + counter.ToString (), (i++).ToString ()));
2949                         //                Assert.AreEqual (tostring_false_true, mtp.ToString (false, true), string.Format(""{0}-#{1} (tostring_false_true)"", test_name + counter.ToString (), (i++).ToString ()));
2950                         //                Assert.AreEqual (tostring_false_false, mtp.ToString (false, false), string.Format(""{0}-#{1} (tostring_false_false)"", test_name + counter.ToString (), (i++).ToString ()));
2951
2952                         //                }
2953                         //        ".Replace ("{", "{").Replace ("}", "}"));
2954                 }
2955
2956                 static void WriteAssertProperties (MS_System_ComponentModel.MaskedTextProvider mtp, string Name, string TestName, ref int i)
2957                 {
2958                         StringBuilder call = new StringBuilder ();
2959                         call.Append ("MaskedTextProviderTest.AssertProperties (mtp, \"" + TestName + "\", " + (i++).ToString ());
2960                         call.Append (", " + GetStringValue (mtp.AllowPromptAsInput));
2961                         call.Append (", " + GetStringValue (mtp.AsciiOnly));
2962                         call.Append (", " + GetStringValue (mtp.AssignedEditPositionCount));
2963                         call.Append (", " + GetStringValue (mtp.AvailableEditPositionCount));
2964                         call.Append (", " + GetStringValue (mtp.Culture));
2965                         call.Append (", " + GetStringValue (mtp.EditPositionCount));
2966                         //call.Append (", " + GetStringValue (mtp.EditPositions));
2967                         call.Append (", " + GetStringValue (mtp.IncludeLiterals));
2968                         call.Append (", " + GetStringValue (mtp.IncludePrompt));
2969                         call.Append (", " + GetStringValue (mtp.IsPassword));
2970                         call.Append (", " + GetStringValue (mtp.LastAssignedPosition));
2971                         call.Append (", " + GetStringValue (mtp.Length));
2972                         call.Append (", " + GetStringValue (mtp.Mask));
2973                         call.Append (", " + GetStringValue (mtp.MaskCompleted));
2974                         call.Append (", " + GetStringValue (mtp.MaskFull));
2975                         call.Append (", " + GetStringValue (mtp.PasswordChar));
2976                         call.Append (", " + GetStringValue (mtp.PromptChar));
2977                         call.Append (", " + GetStringValue (mtp.ResetOnPrompt));
2978                         call.Append (", " + GetStringValue (mtp.ResetOnSpace));
2979                         call.Append (", " + GetStringValue (mtp.SkipLiterals));
2980                         call.Append (", " + QuoteString (mtp.ToString ()));
2981                         call.Append (", " + QuoteString (mtp.ToString (true)));
2982                         call.Append (", " + QuoteString (mtp.ToString (false)));
2983                         call.Append (", " + QuoteString (mtp.ToString (true, true)));
2984                         call.Append (", " + QuoteString (mtp.ToString (true, false)));
2985                         call.Append (", " + QuoteString (mtp.ToString (false, true)));
2986                         call.Append (", " + QuoteString (mtp.ToString (false, false)));
2987                         call.Append (");");
2988                         WriteLine (call.ToString ());
2989                 }
2990
2991                 static string QuoteString (string str)
2992                 {
2993                         return "@\"" + str.Replace ("\"", "\"\"") + "\"";
2994                 }
2995
2996                 //static void WriteAssertProperties2 (MS_System_ComponentModel.MaskedTextProvider mtp, string Name, string TestName, ref int i)
2997                 //{
2998                 //        WriteLine ("// Testing all properties...");
2999                 //        //return;
3000                 //        WriteLine ("Assert.AreEqual ({0}, {1}.AllowPromptAsInput, \"{2}-#{3}\");", GetStringValue (mtp.AllowPromptAsInput), Name, TestName, (i++).ToString ());
3001                 //        WriteLine ("Assert.AreEqual ({0}, {1}.AsciiOnly, \"{2}-#{3}\");", GetStringValue (mtp.AsciiOnly), Name, TestName, (i++).ToString ());
3002                 //        WriteLine ("Assert.AreEqual ({0}, {1}.AssignedEditPositionCount, \"{2}-#{3}\");", GetStringValue (mtp.AssignedEditPositionCount), Name, TestName, (i++).ToString ());
3003                 //        WriteLine ("Assert.AreEqual ({0}, {1}.AvailableEditPositionCount, \"{2}-#{3}\");", GetStringValue (mtp.AvailableEditPositionCount), Name, TestName, (i++).ToString ());
3004                 //        //WriteLine ("Assert.AreEqual ({0}, {1}.Culture, \"{2}-#{3}\");", GetStringValue (mtp.Culture), Name, TestName, (i++).ToString ());
3005                 //        WriteLine ("Assert.AreEqual ({0}, {1}.EditPositionCount, \"{2}-#{3}\");", GetStringValue (mtp.EditPositionCount), Name, TestName, (i++).ToString ());
3006                 //        //WriteLine ("Assert.AreEqual ({0}, {1}.EditPositions, \"{2}-#{3}\");", GetStringValue (mtp.EditPositions), Name, TestName, (i++).ToString ());
3007                 //        WriteLine ("Assert.AreEqual ({0}, {1}.IncludeLiterals, \"{2}-#{3}\");", GetStringValue (mtp.IncludeLiterals), Name, TestName, (i++).ToString ());
3008                 //        WriteLine ("Assert.AreEqual ({0}, {1}.IncludePrompt, \"{2}-#{3}\");", GetStringValue (mtp.IncludePrompt), Name, TestName, (i++).ToString ());
3009                 //        WriteLine ("Assert.AreEqual ({0}, {1}.IsPassword, \"{2}-#{3}\");", GetStringValue (mtp.IsPassword), Name, TestName, (i++).ToString ());
3010                 //        WriteLine ("Assert.AreEqual ({0}, {1}.LastAssignedPosition, \"{2}-#{3}\");", GetStringValue (mtp.LastAssignedPosition), Name, TestName, (i++).ToString ());
3011                 //        WriteLine ("Assert.AreEqual ({0}, {1}.Length, \"{2}-#{3}\");", GetStringValue (mtp.Length), Name, TestName, (i++).ToString ());
3012                 //        WriteLine ("Assert.AreEqual ({0}, {1}.Mask, \"{2}-#{3}\");", GetStringValue (mtp.Mask), Name, TestName, (i++).ToString ());
3013                 //        WriteLine ("Assert.AreEqual ({0}, {1}.MaskCompleted, \"{2}-#{3}\");", GetStringValue (mtp.MaskCompleted), Name, TestName, (i++).ToString ());
3014                 //        WriteLine ("Assert.AreEqual ({0}, {1}.MaskFull, \"{2}-#{3}\");", GetStringValue (mtp.MaskFull), Name, TestName, (i++).ToString ());
3015                 //        WriteLine ("Assert.AreEqual ({0}, {1}.PasswordChar, \"{2}-#{3}\");", GetStringValue (mtp.PasswordChar), Name, TestName, (i++).ToString ());
3016                 //        WriteLine ("Assert.AreEqual ({0}, {1}.PromptChar, \"{2}-#{3}\");", GetStringValue (mtp.PromptChar), Name, TestName, (i++).ToString ());
3017                 //        WriteLine ("Assert.AreEqual ({0}, {1}.ResetOnPrompt, \"{2}-#{3}\");", GetStringValue (mtp.ResetOnPrompt), Name, TestName, (i++).ToString ());
3018                 //        WriteLine ("Assert.AreEqual ({0}, {1}.ResetOnSpace, \"{2}-#{3}\");", GetStringValue (mtp.ResetOnSpace), Name, TestName, (i++).ToString ());
3019                 //        WriteLine ("Assert.AreEqual ({0}, {1}.SkipLiterals, \"{2}-#{3}\");", GetStringValue (mtp.SkipLiterals), Name, TestName, (i++).ToString ());
3020                 //}
3021         }
3022 }