public void CodePieceTest_parseFromLine()
{
CodePiece p = CodePiece.ParseFromLine(@"872++:-");
Assert.AreEqual(7, p.Width);
Assert.AreEqual(1, p.Height);
}
public override CodePiece GenerateCode(CodeGenEnvironment env, bool reversed)
{
CodePiece p = new CodePiece();
if (reversed)
{
foreach (char val in Value.Reverse <char>()) // Reverse Value -> correct stack order
{
p.AppendLeft(NumberCodeFactoryStringmodeChar.GenerateCode(val, reversed) ?? NumberCodeHelper.GenerateCode(val, reversed));
}
}
else
{
foreach (char val in Value.Reverse <char>()) // Reverse Value -> correct stack order
{
p.AppendRight(NumberCodeFactoryStringmodeChar.GenerateCode(val, reversed) ?? NumberCodeHelper.GenerateCode(val, reversed));
}
}
p.NormalizeX();
p.TrimDoubleStringMode();
return(p);
}
public static CodePiece GenerateCode(long lit)
{
bool isneg;
if (isneg = lit < 0)
{
lit *= -1;
}
CodePiece p = new CodePiece();
if (lit == 0)
{
p[0, 0] = BCHelper.Digit0;
return(p);
}
if (isneg)
{
p.AppendRight(BCHelper.Digit0);
}
GetFactors(p, lit);
if (isneg)
{
p.AppendRight(BCHelper.Sub);
}
return(p);
}
public override CodePiece GenerateCode_SetToStackVal(CodeGenEnvironment env, bool reversed)
{
if (IsConstant)
{
throw new ConstantValueChangedException(Position, Identifier);
}
CodePiece p = new CodePiece();
int varX = CodeDeclarationPos.X;
int varY = CodeDeclarationPos.Y;
if (reversed)
{
p.AppendLeft(NumberCodeHelper.GenerateCode(varX, reversed));
p.AppendLeft(NumberCodeHelper.GenerateCode(varY, reversed));
p.AppendLeft(BCHelper.ReflectSet);
}
else
{
p.AppendRight(NumberCodeHelper.GenerateCode(varX, reversed));
p.AppendRight(NumberCodeHelper.GenerateCode(varY, reversed));
p.AppendRight(BCHelper.ReflectSet);
}
p.NormalizeX();
return(p);
}
public void CodePieceTest_normalize()
{
CodePiece p = new CodePiece();
p[-1, -1] = BCHelper.PCDown;
p[+1, +1] = BCHelper.PCDown;
Assert.AreEqual(-1, p.MinX);
Assert.AreEqual(-1, p.MinY);
Assert.AreEqual(2, p.MaxX);
Assert.AreEqual(2, p.MaxY);
p.NormalizeX();
Assert.AreEqual(0, p.MinX);
Assert.AreEqual(-1, p.MinY);
Assert.AreEqual(3, p.MaxX);
Assert.AreEqual(2, p.MaxY);
p.NormalizeY();
Assert.AreEqual(0, p.MinX);
Assert.AreEqual(0, p.MinY);
Assert.AreEqual(3, p.MaxX);
Assert.AreEqual(3, p.MaxY);
}
public override CodePiece GenerateCodeAssignment(CodeGenEnvironment env, SourceCodePosition pos, Expression source, ExpressionValuePointer target, bool reversed)
{
CodePiece p = new CodePiece();
if (reversed)
{
p.AppendLeft(source.GenerateCode(env, reversed));
p.AppendLeft(target.GenerateCodeSingle(env, reversed));
p.AppendLeft(BCHelper.ReflectSet);
p.NormalizeX();
}
else
{
p.AppendRight(source.GenerateCode(env, reversed));
p.AppendRight(target.GenerateCodeSingle(env, reversed));
p.AppendRight(BCHelper.ReflectSet);
p.NormalizeX();
}
return(p);
}
public void CodePieceTest_forceNonEmpty()
{
CodePiece p = new CodePiece();
p.ForceNonEmpty(BCHelper.Add);
Assert.AreEqual(1, p.Size);
}
public void CodePieceTest_IsSingle()
{
CodePiece p = CodePiece.ParseFromLine("13373");
Assert.AreEqual(true, p.FirstColumnIsSingle());
Assert.AreEqual(false, p.FirstRowIsSingle());
}
public static CodePiece GenerateCode(bool value)
{
CodePiece p = new CodePiece();
p[0, 0] = BCHelper.Dig(value ? (byte)1 : (byte)0);
return(p);
}
private CodePiece GenerateCode_Display(CodePiece val)
{
MathExt.Point s = new MathExt.Point(DisplayWidth, DisplayHeight);
int b = CGO.DisplayBorderThickness;
CodePiece p = new CodePiece();
if (s.Size == 0)
{
return(p);
}
p.SetAt(b, b, val);
// 44111111
// 44111111
// 44 22
// 44 22
// 44 22
// 44 22
// 33333322
// 33333322
p.Fill(b, 0, s.X + 2 * b, b, BCHelper.Chr(CGO.DisplayBorder)); // 1
p.Fill(s.X + b, b, s.X + 2 * b, s.Y + 2 * b, BCHelper.Chr(CGO.DisplayBorder)); // 2
p.Fill(0, s.Y + b, s.X + b, s.Y + 2 * b, BCHelper.Chr(CGO.DisplayBorder)); // 3
p.Fill(0, 0, b, s.Y + b, BCHelper.Chr(CGO.DisplayBorder)); // 4
p.SetTag(0, 0, new DisplayTopLeftTag(this, DisplayWidth + 2 * b, DisplayHeight + 2 * b));
return(p);
}
public void CodePieceTest_IsFlat()
{
CodePiece p = CodePiece.ParseFromLine("13373");
Assert.AreEqual(true, p.IsHFlat());
Assert.AreEqual(false, p.IsVFlat());
}
public void CodePieceTest_Set()
{
CodePiece cp = new CodePiece();
cp[0, 0] = new BefungeCommand(BefungeCommandType.Add);
Assert.AreEqual(1, cp.Width);
Assert.AreEqual(1, cp.Height);
cp[0, 2] = new BefungeCommand(BefungeCommandType.Add);
Assert.AreEqual(1, cp.Width);
Assert.AreEqual(3, cp.Height);
cp[2, 0] = new BefungeCommand(BefungeCommandType.Add);
Assert.AreEqual(3, cp.Width);
Assert.AreEqual(3, cp.Height);
cp[2, 2] = new BefungeCommand(BefungeCommandType.Add);
Assert.AreEqual(3, cp.Width);
Assert.AreEqual(3, cp.Height);
cp[0, -2] = new BefungeCommand(BefungeCommandType.Add);
Assert.AreEqual(3, cp.Width);
Assert.AreEqual(5, cp.Height);
cp[-2, 0] = new BefungeCommand(BefungeCommandType.Add);
Assert.AreEqual(5, cp.Width);
Assert.AreEqual(5, cp.Height);
cp[-2, -2] = new BefungeCommand(BefungeCommandType.Add);
Assert.AreEqual(5, cp.Width);
Assert.AreEqual(5, cp.Height);
}
private static void GetFactors(CodePiece p, long a) // Wenn nicht möglich so gut wie mögl und am ende add
{
List <int> result = new List <int>();
if (a < 10)
{
p.AppendRight(BCHelper.Dig((byte)a));
return;
}
for (byte i = 9; i > 1; i--)
{
if (a % i == 0)
{
GetFactors(p, a / i);
p.AppendRight(BCHelper.Dig(i));
p.AppendRight(BCHelper.Mult);
return;
}
}
for (byte i = 1; i < 10; i++)
{
if ((a - i) % 9 == 0)
{
GetFactors(p, a - i);
p.AppendRight(BCHelper.Dig(i));
p.AppendRight(BCHelper.Add);
return;
}
}
throw new WTFException();
}
public void CodePieceTest_AddOffset()
{
CodePiece p = new CodePiece(BCHelper.Add);
p.AddOffset(10, 10);
Assert.AreEqual(BefungeCommandType.Add, p[10, 10].Type);
}
public void CodePieceTest_Clear()
{
CodePiece p = CodePiece.ParseFromLine("123**");
p.Clear();
Assert.AreEqual(0, p.Size);
}
public void CodePieceTest_RemoveRow()
{
CodePiece p = CodePiece.ParseFromLine("123456");
p.RemoveRow(0);
Assert.AreEqual(0, p.Size);
}
public void CodePieceTest_setTag()
{
CodePiece p = new CodePiece(BCHelper.PCDown);
p.SetTag(0, 0, new TemporaryCodeFieldTag());
Assert.AreEqual(true, p.HasActiveTag(typeof(TemporaryCodeFieldTag)));
}
public void CodePieceTest_Fill()
{
CodePiece p = new CodePiece();
p.Fill(0, 0, 10, 10, BCHelper.Walkway);
Assert.AreEqual(10, p.Width);
Assert.AreEqual(10, p.Height);
}
public async Task <string> Score(string userInput)
{
return(await Task.Run(() =>
{
var secretCode = CodePiece.DecipherCode(_secretCode).ToList();
var userCode = CodePiece.DecipherCode(userInput).ToList();
return $"{GetPerfectMatchScore(userCode, secretCode)}{GetCloseMatchScore(userCode, secretCode)}";
}));
}
public static void debugProgram_Output(string p_out, string prog)
{
prog = prog.Replace(@"''", "\"");
Program e = parseProgram(prog);
CodePiece pc = e.GenerateCode();
TestCP_Output(pc, p_out);
}
public static void debugProgram_Terminate(string prog)
{
prog = prog.Replace(@"''", "\"");
Program e = parseProgram(prog);
CodePiece pc = e.GenerateCode();
TestCP_Terminate(pc);
}
public static void debugStatement_Output(string stmt, string op)
{
stmt = stmt.Replace(@"''", "\"");
Program e = parseStatement(stmt);
CodePiece pc = e.GenerateCode();
TestCP_Output(pc, op);
}
public static void debugStatement_NonTerminate(string stmt)
{
stmt = stmt.Replace(@"''", "\"");
Program e = parseStatement(stmt);
CodePiece pc = e.GenerateCode();
TestCP(pc);
}
public static CodePiece GenerateCode(long value, bool reversed)
{
CodePiece p = GenerateCode(value);
if (reversed)
{
p.ReverseX(false);
}
return(p);
}
public void CodePieceTest_TrimDoubleStringMode()
{
CodePiece p = CodePiece.CombineHorizontal(CodePiece.ParseFromLine("\"111\""), CodePiece.ParseFromLine("\"000\""));
Assert.AreEqual(10, p.Width);
p.TrimDoubleStringMode();
Assert.AreEqual(8, p.Width);
}
public void CodePieceTest_RemoveColum()
{
CodePiece p = CodePiece.ParseFromLine("123456");
Assert.AreEqual(6, p.Width);
p.RemoveColumn(0);
Assert.AreEqual(5, p.Width);
}
public static string GenerateBenchmark(int cnt, bool doNeg)
{
ASTObject.CGO.NumberLiteralRepresentation = NumberRep.Best;
int min = (doNeg) ? -(cnt / 2) : (0);
int max = (doNeg) ? +(cnt / 2) : (cnt);
List <NumberRep> reps = Enum.GetValues(typeof(NumberRep)).Cast <NumberRep>().Where(p => p != NumberRep.Best).ToList();
int[] count = new int[reps.Count];
Array.Clear(count, 0, reps.Count);
//int mxw = Enumerable.Range(MIN, MAX + 1).Max(p1 => generateAllCode(p1, true).Max(p2 => p2.Item2.Width)) + 3;
int mxw = 24;
StringBuilder txt = new StringBuilder();
txt.AppendFormat("{0, -7} ", "Number");
txt.AppendFormat("{0, -16} {1, -" + mxw + "}", "Best", "Best");
reps.ForEach(p => txt.AppendFormat("{0, -" + mxw + "} ", p.ToString()));
txt.AppendLine();
txt.AppendLine();
long ticks = Environment.TickCount;
for (int i = min; i <= max; i++)
{
List <Tuple <NumberRep, CodePiece> > all = GenerateAllCode(i, false);
CodePiece best = GenerateCode(i);
NumberRep rbest = LastRep;
count[reps.IndexOf(rbest)]++;
txt.AppendFormat("{0, -7} ", i.ToString());
txt.AppendFormat("{0, -16} ", rbest.ToString());
txt.AppendFormat("{0, -" + mxw + "} ", best.ToSimpleString());
reps.ForEach(p => txt.AppendFormat("{0, -" + mxw + "} ", (all.Single(p2 => p2.Item1 == p).Item2 != null) ? (all.Single(p2 => p2.Item1 == p).Item2.ToSimpleString()) : ("")));
txt.AppendLine();
}
txt.AppendLine();
txt.AppendLine(new String('#', 32));
txt.AppendLine();
ticks = Environment.TickCount - ticks;
reps.ForEach(p => txt.AppendLine(String.Format("{0,-16}: {1}", p.ToString(), count[reps.IndexOf(p)])));
txt.AppendLine();
txt.AppendLine(String.Format("Time taken for {0} Elements: {1}ms", cnt, ticks));
txt.AppendLine(String.Format("Time/Number: {0:0.000}ms", (ticks * 1.0) / cnt));
return(txt.ToString());
}
public void CodePieceTest_reverseX()
{
CodePiece p1 = CodePiece.ParseFromLine("123**");
CodePiece p2 = CodePiece.ParseFromLine(">123**<");
p1.ReverseX(false);
p2.ReverseX(true);
Assert.AreEqual("**321", p1.ToSimpleString());
Assert.AreEqual(">**321<", p2.ToSimpleString());
}
public static CodePiece GenerateCode(long d)
{
if (d < 0 || d > 9)
{
return(null);
}
CodePiece p = new CodePiece();
p[0, 0] = BCHelper.Dig((byte)d);
return(p);
}
public static void debugMethod_Output(string o, string call, string meth)
{
meth = Regex.Replace(meth, @"[\r\n]{1,2}[ \t]+[\r\n]{1,2}", "\r\n");
meth = Regex.Replace(meth, @"^[ \t]*[\r\n]{1,2}", "");
meth = Regex.Replace(meth, @"[\r\n]{1,2}[ \t]*$", "");
meth = meth.Replace(@"''", "\"");
Program e = parseMethod(call, meth);
CodePiece pc = e.GenerateCode();
TestCP_Output(pc, o);
}
