public void MM_DDInRange01_12DotDelimited()
{
List <string> javaExpectedResult = new()
{
"MM.dd.yyyy",
"dd.MM.yyyy",
};
List <string> javaResult = Guesser.GuessFormat("01.02.2020", Format.Java);
Assert.Equal(2, javaResult.Count);
Assert.Equal(javaExpectedResult.OrderBy(s => s).ToList(), javaResult.OrderBy(s => s).ToList());
List <string> momentExpectedResult = new()
{
"MM.DD.YYYY",
"DD.MM.YYYY",
};
List <string> momentResult = Guesser.GuessFormat("01.02.2020", Format.Moment);
Assert.Equal(2, momentResult.Count);
Assert.Equal(momentExpectedResult.OrderBy(s => s).ToList(), momentResult.OrderBy(s => s).ToList());
List <string> linuxExpectedResult = new()
{
"%d.%m.%Y",
"%m.%d.%Y",
};
List <string> linuxResult = Guesser.GuessFormat("01.02.2020", Format.Linux);
Assert.Equal(2, linuxResult.Count);
Assert.Equal(linuxExpectedResult.OrderBy(s => s).ToList(), linuxResult.OrderBy(s => s).ToList());
}
public void TestGuesser_IntThenLong()
{
Guesser t = new Guesser();
//we see an int
t.AdjustToCompensateForValue("-100");
//we guess the column contains ints
Assert.AreEqual(typeof(int), t.Guess.CSharpType);
Assert.AreEqual(4, t.Guess.Width);
Assert.AreEqual(3, t.Guess.Size.NumbersBeforeDecimalPlace);
Assert.AreEqual(0, t.Guess.Size.NumbersAfterDecimalPlace);
//we see a long
t.AdjustToCompensateForValue("9223372036854775807");
//we change our estimate to the compatible estimate of 'decimal'
Assert.AreEqual(typeof(decimal), t.Guess.CSharpType);
Assert.AreEqual(19, t.Guess.Width);
Assert.AreEqual(19, t.Guess.Size.NumbersBeforeDecimalPlace);
Assert.AreEqual(0, t.Guess.Size.NumbersAfterDecimalPlace);
//final estimate is decimal
Assert.AreEqual(typeof(decimal), t.Guess.CSharpType);
}
public static void Main(string[] args)
{
var wb = new WordBase(Directory.GetFiles("dictionaries"));
wb.Files.AddRange(Directory.GetFiles("downloads"));
wb.Init();
System.Console.Write("Сколько букв? ");
var n = int.Parse(System.Console.ReadLine());
var g = new Guesser(n, wb);
while (true)
{
var guess = g.GuessAnswer();
var l = guess.Letter;
var c = g.Attempts;
System.Console.WriteLine($"Попытка №{c} Шаблон: {g.Matcher.Pattern}");
System.Console.WriteLine($"Где буква '{l}'?");
var d = (from i in System.Console.ReadLine().Split() select int.Parse(i)).ToArray();
g.Hint(l, d);
if (g.Matcher.Unknown == 0)
{
System.Console.WriteLine($"Угадано слово '{g.Matcher.Pattern}' c {c} попытки!");
break;
}
}
}
private void CopySettings(Guesser guesser, CreateTableArgs args)
{
//cannot change the instance so have to copy across the values. If this gets new properties that's a problem
//See tests GuessSettings_CopyProperties
guesser.Settings.CharCanBeBoolean = args.GuessSettings.CharCanBeBoolean;
guesser.Settings.ExplicitDateFormats = args.GuessSettings.ExplicitDateFormats;
}
public void ExampleUsage()
{
var guesser = new Guesser();
guesser.AdjustToCompensateForValue("-12.211");
var guess = guesser.Guess;
Assert.AreEqual(typeof(decimal), guess.CSharpType);
Assert.AreEqual(2, guess.Size.NumbersBeforeDecimalPlace);
Assert.AreEqual(3, guess.Size.NumbersAfterDecimalPlace);
Assert.AreEqual(7, guess.Width);
guesser = new Guesser();
guesser.AdjustToCompensateForValue("1,000");
guesser.AdjustToCompensateForValue("0.001");
guess = guesser.Guess;
Assert.AreEqual(typeof(decimal), guess.CSharpType);
Assert.AreEqual(4, guess.Size.NumbersBeforeDecimalPlace);
Assert.AreEqual(3, guess.Size.NumbersAfterDecimalPlace);
Assert.AreEqual(8, guess.Width);//?
var someStrings = new [] { "13:11:59", "9AM" };
guesser = new Guesser();
guesser.AdjustToCompensateForValues(someStrings);
var parsed = someStrings.Select(guesser.Parse).ToArray();
Assert.AreEqual(new TimeSpan(13, 11, 59), parsed[0]);
Assert.AreEqual(new TimeSpan(9, 0, 0), parsed[1]);
}
public void Dash_DD_MM_YY_MM()
{
List <string> javaExpectedResult = new()
{
"dd-MM",
"yy-MM",
};
List <string> javaResult = Guesser.GuessFormat("31-12", Format.Java);
Assert.Equal(2, javaResult.Count);
Assert.Equal(javaExpectedResult.OrderBy(s => s).ToList(), javaResult.OrderBy(s => s).ToList());
List <string> momentExpectedResult = new()
{
"DD-MM",
"YY-MM",
};
List <string> momentResult = Guesser.GuessFormat("31-12", Format.Moment);
Assert.Equal(2, momentResult.Count);
Assert.Equal(momentExpectedResult.OrderBy(s => s).ToList(), momentResult.OrderBy(s => s).ToList());
List <string> linuxExpectedResult = new()
{
"%y-%m",
"%d-%m",
};
List <string> linuxResult = Guesser.GuessFormat("31-12", Format.Linux);
Assert.Equal(2, linuxResult.Count);
Assert.Equal(linuxExpectedResult.OrderBy(s => s).ToList(), linuxResult.OrderBy(s => s).ToList());
}
public virtual Guesser GetGuesserFor(DiscoveredColumn discoveredColumn)
{
var reqType = GetDataTypeRequestForSQLDBType(discoveredColumn.DataType.SQLType);
var req = new Guesser(reqType);
return(req);
}
public void MM_DDInRange01_12ShortFormDashDelimited()
{
List <string> javaExpectedResult = new()
{
"yy-MM",
"dd-MM",
"MM-dd",
};
List <string> javaResult = Guesser.GuessFormat("01-01", Format.Java);
Assert.Equal(3, javaResult.Count);
Assert.Equal(javaExpectedResult.OrderBy(s => s).ToList(), javaResult.OrderBy(s => s).ToList());
List <string> momentExpectedResult = new()
{
"YY-MM",
"DD-MM",
"MM-DD",
};
List <string> momentResult = Guesser.GuessFormat("01-01", Format.Moment);
Assert.Equal(3, momentResult.Count);
Assert.Equal(momentExpectedResult.OrderBy(s => s).ToList(), momentResult.OrderBy(s => s).ToList());
List <string> linuxExpectedResult = new()
{
"%y-%m",
"%d-%m",
"%m-%d",
};
List <string> linuxResult = Guesser.GuessFormat("01-01", Format.Linux);
Assert.Equal(3, linuxResult.Count);
Assert.Equal(linuxExpectedResult.OrderBy(s => s).ToList(), linuxResult.OrderBy(s => s).ToList());
}
public void Dot_MM_DD()
{
List <string> javaExpectedResult = new()
{
"MM.dd",
"HH.mm",
};
List <string> javaResult = Guesser.GuessFormat("12.31", Format.Java);
Assert.Equal(2, javaResult.Count);
Assert.Equal(javaExpectedResult.OrderBy(s => s).ToList(), javaResult.OrderBy(s => s).ToList());
List <string> momentExpectedResult = new()
{
"MM.DD",
"HH.mm",
};
List <string> momentResult = Guesser.GuessFormat("12.31", Format.Moment);
Assert.Equal(2, momentResult.Count);
Assert.Equal(momentExpectedResult.OrderBy(s => s).ToList(), momentResult.OrderBy(s => s).ToList());
List <string> linuxExpectedResult = new()
{
"%m.%d",
"%H.%M",
};
List <string> linuxResult = Guesser.GuessFormat("12.31", Format.Linux);
Assert.Equal(2, linuxResult.Count);
Assert.Equal(linuxExpectedResult.OrderBy(s => s).ToList(), linuxResult.OrderBy(s => s).ToList());
}
public void YYInRange13_31PlacedFirstSlashDelimited()
{
List <string> javaExpectedResult = new()
{
"yy/MM/dd",
"dd/MM/yy",
};
List <string> javaResult = Guesser.GuessFormat("13/02/01", Format.Java);
Assert.Equal(2, javaResult.Count);
Assert.Equal(javaExpectedResult.OrderBy(s => s).ToList(), javaResult.OrderBy(s => s).ToList());
List <string> momentExpectedResult = new()
{
"YY/MM/DD",
"DD/MM/YY",
};
List <string> momentResult = Guesser.GuessFormat("13/02/01", Format.Moment);
Assert.Equal(2, momentResult.Count);
Assert.Equal(momentExpectedResult.OrderBy(s => s).ToList(), momentResult.OrderBy(s => s).ToList());
List <string> linuxExpectedResult = new()
{
"%y/%m/%d",
"%d/%m/%y",
};
List <string> linuxResult = Guesser.GuessFormat("13/02/01", Format.Linux);
Assert.Equal(2, linuxResult.Count);
Assert.Equal(linuxExpectedResult.OrderBy(s => s).ToList(), linuxResult.OrderBy(s => s).ToList());
}
public void YYInRange13_31PlacedFirstDotDelimited()
{
List <string> javaExpectedResult = new()
{
"yy.MM.dd",
"dd.MM.yy",
"HH.mm.ss",
};
List <string> javaResult = Guesser.GuessFormat("13.02.01", Format.Java);
Assert.Equal(3, javaResult.Count);
Assert.Equal(javaExpectedResult.OrderBy(s => s).ToList(), javaResult.OrderBy(s => s).ToList());
List <string> momentExpectedResult = new()
{
"YY.MM.DD",
"DD.MM.YY",
"HH.mm.ss",
};
List <string> momentResult = Guesser.GuessFormat("13.02.01", Format.Moment);
Assert.Equal(3, momentResult.Count);
Assert.Equal(momentExpectedResult.OrderBy(s => s).ToList(), momentResult.OrderBy(s => s).ToList());
List <string> linuxExpectedResult = new()
{
"%y.%m.%d",
"%d.%m.%y",
"%H.%M.%S",
};
List <string> linuxResult = Guesser.GuessFormat("13.02.01", Format.Linux);
Assert.Equal(3, linuxResult.Count);
Assert.Equal(linuxExpectedResult.OrderBy(s => s).ToList(), linuxResult.OrderBy(s => s).ToList());
}
public void MM_DD_YYInRange01_12DotDelimitedWithDotDelimitedTime()
{
List <string> javaExpectedResult = new()
{
"yy.MM.dd HH.mm z",
"MM.dd.yy HH.mm z",
"dd.MM.yy HH.mm z",
};
List <string> javaResult = Guesser.GuessFormat("01.02.03 10.00 PDT", Format.Java);
Assert.Equal(3, javaResult.Count);
Assert.Equal(javaExpectedResult.OrderBy(s => s).ToList(), javaResult.OrderBy(s => s).ToList());
List <string> momentExpectedResult = new()
{
"YY.MM.DD HH.mm z",
"MM.DD.YY HH.mm z",
"DD.MM.YY HH.mm z",
};
List <string> momentResult = Guesser.GuessFormat("01.02.03 10.00 PDT", Format.Moment);
Assert.Equal(3, momentResult.Count);
Assert.Equal(momentExpectedResult.OrderBy(s => s).ToList(), momentResult.OrderBy(s => s).ToList());
List <string> linuxExpectedResult = new()
{
"%y.%m.%d %H.%M %Z",
"%d.%m.%y %H.%M %Z",
"%m.%d.%y %H.%M %Z",
};
List <string> linuxResult = Guesser.GuessFormat("01.02.03 10.00 PDT", Format.Linux);
Assert.Equal(3, linuxResult.Count);
Assert.Equal(linuxExpectedResult.OrderBy(s => s).ToList(), linuxResult.OrderBy(s => s).ToList());
}
public void MM_DD_YYInRange01_12SlashDelimitedWithTime()
{
List <string> javaExpectedResult = new()
{
"yy/MM/dd hh:mm a",
"MM/dd/yy hh:mm a",
"dd/MM/yy hh:mm a",
};
List <string> javaResult = Guesser.GuessFormat("01/02/03 10:00 PM", Format.Java);
Assert.Equal(3, javaResult.Count);
Assert.Equal(javaExpectedResult.OrderBy(s => s).ToList(), javaResult.OrderBy(s => s).ToList());
List <string> momentExpectedResult = new()
{
"YY/MM/DD hh:mm A",
"MM/DD/YY hh:mm A",
"DD/MM/YY hh:mm A",
};
List <string> momentResult = Guesser.GuessFormat("01/02/03 10:00 PM", Format.Moment);
Assert.Equal(3, momentResult.Count);
Assert.Equal(momentExpectedResult.OrderBy(s => s).ToList(), momentResult.OrderBy(s => s).ToList());
List <string> linuxExpectedResult = new()
{
"%y/%m/%d %I:%M %p",
"%d/%m/%y %I:%M %p",
"%m/%d/%y %I:%M %p",
};
List <string> linuxResult = Guesser.GuessFormat("01/02/03 10:00 PM", Format.Linux);
Assert.Equal(3, linuxResult.Count);
Assert.Equal(linuxExpectedResult.OrderBy(s => s).ToList(), linuxResult.OrderBy(s => s).ToList());
}
public void MM_DDInRange01_12DashDelimited()
{
List <string> javaExpectedResult = new()
{
"MM-dd-yyyy",
"dd-MM-yyyy",
};
List <string> javaResult = Guesser.GuessFormat("01-02-2020", Format.Java);
Assert.Equal(2, javaResult.Count);
Assert.Equal(javaExpectedResult.OrderBy(s => s).ToList(), javaResult.OrderBy(s => s).ToList());
List <string> momentExpectedResult = new()
{
"MM-DD-YYYY",
"DD-MM-YYYY",
};
List <string> momentResult = Guesser.GuessFormat("01-02-2020", Format.Moment);
Assert.Equal(2, momentResult.Count);
Assert.Equal(momentExpectedResult.OrderBy(s => s).ToList(), momentResult.OrderBy(s => s).ToList());
List <string> linuxExpectedResult = new()
{
"%d-%m-%Y",
"%m-%d-%Y",
};
List <string> linuxResult = Guesser.GuessFormat("01-02-2020", Format.Linux);
Assert.Equal(2, linuxResult.Count);
Assert.Equal(linuxExpectedResult.OrderBy(s => s).ToList(), linuxResult.OrderBy(s => s).ToList());
}
public void TestGuesser_DateTime_DodgyFormats(string input, Type expectedOutput)
{
Guesser t = new Guesser();
t.AdjustToCompensateForValue(input);
Assert.AreEqual(expectedOutput, t.Guess.CSharpType);
}
public void TestGuesser_RandomCrud(string randomCrud)
{
Guesser t = new Guesser();
t.AdjustToCompensateForValue(randomCrud);
Assert.AreEqual(typeof(string), t.Guess.CSharpType);
}
public void MM_DDInRange01_12SlashDelimited()
{
List <string> javaExpectedResult = new()
{
"MM/dd/yyyy",
"dd/MM/yyyy",
};
List <string> javaResult = Guesser.GuessFormat("01/02/2020", Format.Java);
Assert.Equal(2, javaResult.Count);
Assert.Equal(javaExpectedResult.OrderBy(s => s).ToList(), javaResult.OrderBy(s => s).ToList());
List <string> momentExpectedResult = new()
{
"MM/DD/YYYY",
"DD/MM/YYYY",
};
List <string> momentResult = Guesser.GuessFormat("01/02/2020", Format.Moment);
Assert.Equal(2, momentResult.Count);
Assert.Equal(momentExpectedResult.OrderBy(s => s).ToList(), momentResult.OrderBy(s => s).ToList());
List <string> linuxExpectedResult = new()
{
"%d/%m/%Y",
"%m/%d/%Y",
};
List <string> linuxResult = Guesser.GuessFormat("01/02/2020", Format.Linux);
Assert.Equal(2, linuxResult.Count);
Assert.Equal(linuxExpectedResult.OrderBy(s => s).ToList(), linuxResult.OrderBy(s => s).ToList());
}
[TestCase("5,000", typeof(int), "de-de", 5, 1, 0, 5)] //germans swap commas and dots
public void Test_OneString_IsType(string guessFor, Type expectedGuess, string culture, int expectedStringLength, int expectedBefore, int expectedAfter, object expectedParseValue)
{
var cultureInfo = new CultureInfo(culture);
var guesser = new Guesser()
{
Culture = cultureInfo
};
guesser.AdjustToCompensateForValue(guessFor);
Assert.AreEqual(expectedGuess, guesser.Guess.CSharpType, "Guessed Type did not match");
Assert.AreEqual(expectedStringLength, guesser.Guess.Width, "String length guessed didn't match");
Assert.AreEqual(expectedBefore, guesser.Guess.Size.NumbersBeforeDecimalPlace, "BeforeDecimalPlace didn't match");
Assert.AreEqual(expectedAfter, guesser.Guess.Size.NumbersAfterDecimalPlace, "AfterDecimalPlace didn't match");
TypeDeciderFactory factory = new TypeDeciderFactory(cultureInfo);
if (factory.IsSupported(guesser.Guess.CSharpType))
{
Assert.AreEqual(expectedParseValue, factory.Create(guesser.Guess.CSharpType).Parse(guessFor));
}
else
{
Assert.AreEqual(expectedParseValue, guessFor);
}
}
public void TestGuesser_ValidDateStrings(string wierdDateString)
{
Guesser t = new Guesser();
t.AdjustToCompensateForValue(wierdDateString);
Assert.AreEqual(typeof(DateTime), t.Guess.CSharpType);
}
public void TestGuesser_Bool(bool sendStringEquiv)
{
Guesser t = new Guesser();
if (sendStringEquiv)
{
t.AdjustToCompensateForValue("True");
}
else
{
t.AdjustToCompensateForValue(true);
}
if (sendStringEquiv)
{
t.AdjustToCompensateForValue("False");
}
else
{
t.AdjustToCompensateForValue(false);
}
Assert.AreEqual(typeof(bool), t.Guess.CSharpType);
t.AdjustToCompensateForValue(null);
Assert.AreEqual(typeof(bool), t.Guess.CSharpType);
Assert.AreEqual(0, t.Guess.Size.NumbersAfterDecimalPlace);
Assert.AreEqual(0, t.Guess.Size.NumbersBeforeDecimalPlace);
}
public void TestGuesser_IntToDateTime()
{
Guesser t = new Guesser();
t.AdjustToCompensateForValue("2013");
t.AdjustToCompensateForValue("01/01/2001");
Assert.AreEqual(typeof(string), t.Guess.CSharpType);
}
public void TestGuesser_TimeObject()
{
Guesser t = new Guesser();
t.AdjustToCompensateForValue(new TimeSpan(10, 1, 1));
Assert.AreEqual(typeof(TimeSpan), t.Guess.CSharpType);
}
public void TestGuesser_Midnight()
{
Guesser t = new Guesser();
t.AdjustToCompensateForValue("00:00");
Assert.AreEqual(typeof(TimeSpan), t.Guess.CSharpType);
}
public void TestGuesser_24Hour()
{
Guesser t = new Guesser();
t.AdjustToCompensateForValue("23:01");
Assert.AreEqual(typeof(TimeSpan), t.Guess.CSharpType);
}
public void TestGuesser_TimeWithPM()
{
Guesser t = new Guesser();
t.AdjustToCompensateForValue("1:01PM");
Assert.AreEqual(typeof(TimeSpan), t.Guess.CSharpType);
}
public void TestGuesser_PreeceedingZeroes(string input, int expectedLength)
{
Guesser t = new Guesser();
t.AdjustToCompensateForValue(input);
Assert.AreEqual(typeof(string), t.Guess.CSharpType);
Assert.AreEqual(expectedLength, t.Guess.Width);
}
public void TestGuesser_MixedIntTypes()
{
Guesser t = new Guesser();
t.AdjustToCompensateForValue((Int16)5);
var ex = Assert.Throws <MixedTypingException>(() => t.AdjustToCompensateForValue((Int32)1000));
StringAssert.Contains("We were adjusting to compensate for object '1000' which is of Type 'System.Int32', we were previously passed a 'System.Int16' type", ex.Message);
}
public void TestGuesser_Whitespace(string input, Type expectedType)
{
Guesser t = new Guesser();
t.AdjustToCompensateForValue(input);
Assert.AreEqual(expectedType, t.Guess.CSharpType);
Assert.AreEqual(input.Length, t.Guess.Width);
}
public void TestGuesser_DateTime_EnglishWithTimeAndAM()
{
Guesser t = new Guesser();
t.AdjustToCompensateForValue(GetCultureSpecificDate() + " 11:10AM");
t.AdjustToCompensateForValue(null);
Assert.AreEqual(typeof(DateTime), t.Guess.CSharpType);
}
public void TestGuesser_DateTime()
{
Guesser t = new Guesser();
t.AdjustToCompensateForValue("01/01/2001");
t.AdjustToCompensateForValue(null);
Assert.AreEqual(typeof(DateTime), t.Guess.CSharpType);
}
public static BlockReader Get(Stream stream, int fallbackCodePage)
{
Encoding encoding;
int preamble = Preamble(stream);
if (preamble != 0) // There is a valid BOM here!
encoding = Encoding.GetEncoding(preamble);
else if (fallbackCodePage == -1) // Fallback is "raw" bytes
return Raw(stream);
else if (fallbackCodePage != -2) // Anything but "guess"
encoding = Encoding.GetEncoding(fallbackCodePage);
else // This is the "guess" option
{
int guess = new Guesser(stream).GuessCodePage();
stream.Seek(0, SeekOrigin.Begin);
if (guess == -1) // ==> this is a 7-bit file
encoding = Encoding.ASCII;
else if (guess == 65001)
encoding = Encoding.UTF8;
else // ==> use the machine default
encoding = Encoding.Default;
}
StreamReader reader = new StreamReader(stream, encoding);
return reader.Read;
}
