public void EquatorPermutationCoordTest() //Tests GetEquatorPermutationCoord, SetEquatorPermutationCoord
{
Random random = new Random(7777777);
int length = 50;
int repetitions = 50;
//if solved permutation corresponds to the coordinate 0
//SetEquatorPermutationCoord()
CubieCube expected = CubieCube.CreateSolved();
CubieCube result = CubieCube.FromAlg(Alg.FromRandomMoves(length, random));
Coordinates.SetEquatorOrder(result, 0);
CubingAssert.HaveEqualEquatorEdgePermutation(expected, result);
expected = CubieCube.FromAlg(Alg.FromString("R2 L2"));
result = CubieCube.FromAlg(Alg.FromRandomMoves(length, random));
Coordinates.SetEquatorOrder(result, Coordinates.NumEquatorOrders - 1);
//GetEquatorPermutationCoord()
result = CubieCube.CreateSolved();
Assert.AreEqual(0, Coordinates.GetEquatorOrder(result));
result.ApplyAlg(Alg.FromString("F' R' B' D' L2"));
Assert.AreEqual(0, Coordinates.GetEquatorOrder(result));
//apply B1
int expectedCoord = 17;
CubieCube cube = CubieCube.CreateSolved();
cube.ApplyMove(Move.B1);
int resultCoord = Coordinates.GetEquatorOrder(cube);
Assert.AreEqual(expectedCoord, resultCoord);
//apply B2
expectedCoord = 6;
cube = CubieCube.CreateSolved();
cube.ApplyMove(Move.B2);
resultCoord = Coordinates.GetEquatorOrder(cube);
Assert.AreEqual(expectedCoord, resultCoord);
//if applying GetEquatorPermutationCoord() and SetEquatorPermutationCoord() results in the same array as at the beginning
for (int repetition = 0; repetition < repetitions; repetition++)
{
expected = CubieCube.FromAlg(Alg.FromRandomMoves(length, random));
result = CubieCube.CreateSolved();
int coord = Coordinates.GetEquatorOrder(expected);
Coordinates.SetEquatorOrder(result, coord);
CubingAssert.HaveEqualEquatorEdgePermutation(expected, result);
}
//exceptions
Assert.ThrowsException <ArgumentNullException>(() => Coordinates.GetEquatorOrder(null));
Assert.ThrowsException <ArgumentNullException>(() => Coordinates.SetEquatorOrder(null, 0));
Assert.ThrowsException <ArgumentOutOfRangeException>(() => Coordinates.SetEquatorOrder(CubieCube.CreateSolved(), -1));
Assert.ThrowsException <ArgumentOutOfRangeException>(() => Coordinates.SetEquatorOrder(CubieCube.CreateSolved(), Coordinates.NumEquatorOrders));
}
public void CpCoordTest() //Tests GetCpCoord, SetCpCoord
{
Random random = new Random(7777777);
int length = 50;
//if applying GetCpCoord and SetCpCoord results in the same array as at the beginning
CubieCube expected = CubieCube.FromAlg(Alg.FromRandomMoves(length, random));
CubieCube result = CubieCube.CreateSolved();
int coord = Coordinates.GetCornerPermutation(expected);
Coordinates.SetCornerPermutation(result, coord);
CollectionAssert.AreEqual(expected.CornerPermutation, result.CornerPermutation);
//apply R2 to a solved cube
CubieCube cube = CubieCube.CreateSolved();
cube.ApplyMove(Move.R2);
int expectedCoord = 36177;
int resultCoord = Coordinates.GetCornerPermutation(cube);
Assert.AreEqual(expectedCoord, resultCoord);
expected = CubieCube.CreateSolved();
expected.ApplyMove(Move.R2);
result = CubieCube.CreateSolved();
Coordinates.SetCornerPermutation(result, expectedCoord);
CollectionAssert.AreEqual(expected.CornerPermutation, result.CornerPermutation);
//if solved permutation corresponds to the coordinate 0
expected = CubieCube.CreateSolved();
result = CubieCube.FromAlg(Alg.FromRandomMoves(length, random));
Coordinates.SetCornerPermutation(result, 0);
CollectionAssert.AreEqual(expected.CornerPermutation, result.CornerPermutation);
result = CubieCube.CreateSolved();
Assert.AreEqual(0, Coordinates.GetCornerPermutation(result));
//example from http://kociemba.org/math/coordlevel
Corner[] cp = new Corner[] { Corner.DFR, Corner.UFL, Corner.ULB, Corner.URF, Corner.DRB, Corner.DLF, Corner.DBL, Corner.UBR };
cube = CubieCube.Create(cp, CubieCube.SolvedCO, CubieCube.SolvedEP, CubieCube.SolvedEO, CubieCube.SolvedCenters);
resultCoord = Coordinates.GetCornerPermutation(cube);
expectedCoord = 21021;
Assert.AreEqual(expectedCoord, resultCoord);
//exceptions
Assert.ThrowsException <ArgumentNullException>(() => Coordinates.GetCornerPermutation(null));
Assert.ThrowsException <ArgumentNullException>(() => Coordinates.SetCornerPermutation(null, 0));
Assert.ThrowsException <ArgumentOutOfRangeException>(() => Coordinates.SetCornerPermutation(CubieCube.CreateSolved(), -1));
Assert.ThrowsException <ArgumentOutOfRangeException>(() => Coordinates.SetCornerPermutation(CubieCube.CreateSolved(), Coordinates.NumCornerPermutations));
}
public void EpCoordTest() //Tests GetCpCoord, SetCpCoord
{
Random random = new Random(7777777);
int length = 50;
//if applying GetEpCoord and SetEpCoord results in the same array as at the beginning
CubieCube expected = CubieCube.FromAlg(Alg.FromRandomMoves(length, random));
CubieCube result = CubieCube.CreateSolved();
int coord = Coordinates.GetEdgePermutation(expected);
Coordinates.SetEdgePermutation(result, coord);
CollectionAssert.AreEqual(expected.EdgePermutation, result.EdgePermutation);
//apply R2 to a solved cube
CubieCube cube = CubieCube.CreateSolved();
cube.ApplyMove(Move.R2);
int expectedCoord = 123763104;
int resultCoord = Coordinates.GetEdgePermutation(cube);
Assert.AreEqual(expectedCoord, resultCoord);
expected = CubieCube.CreateSolved();
expected.ApplyMove(Move.R2);
result = CubieCube.CreateSolved();
Coordinates.SetEdgePermutation(result, expectedCoord);
CollectionAssert.AreEqual(expected.EdgePermutation, result.EdgePermutation);
//if solved permutation corresponds to the coordinate 0
expected = CubieCube.CreateSolved();
result = CubieCube.FromAlg(Alg.FromRandomMoves(length, random));
Coordinates.SetEdgePermutation(result, 0);
CollectionAssert.AreEqual(expected.EdgePermutation, result.EdgePermutation);
result = CubieCube.CreateSolved();
Assert.AreEqual(0, Coordinates.GetEdgePermutation(result));
//exceptions
Assert.ThrowsException <ArgumentNullException>(() => Coordinates.GetEdgePermutation(null));
Assert.ThrowsException <ArgumentNullException>(() => Coordinates.SetEdgePermutation(null, 0));
Assert.ThrowsException <ArgumentOutOfRangeException>(() => Coordinates.SetEdgePermutation(CubieCube.CreateSolved(), -1));
Assert.ThrowsException <ArgumentOutOfRangeException>(() => Coordinates.SetEdgePermutation(CubieCube.CreateSolved(), Coordinates.NumEdgePermutations));
}
public void TestAllPhase1()
{
Random random = new Random(7777777);
int length = 50;
int repetitions = 50;
TableController.InitializeCornerOrientationMoveTable();
TableController.InitializeCornerPermutationMoveTable();
TableController.InitializeEdgeOrientationMoveTable();
TableController.InitializeEquatorDistributionMoveTable();
for (int repetition = 0; repetition < repetitions; repetition++)
{
Alg randomMoves = Alg.FromRandomMoves(length, random);
int resultCo = 0;
int resultCp = 0;
int resultEo = 0;
int resultEquatorDistribution = 0;
CubieCube cube = CubieCube.CreateSolved();
for (int moveIndex = 0; moveIndex < length; moveIndex++)
{
resultCo = TableController.CornerOrientationMoveTable[resultCo, (int)randomMoves[moveIndex]];
resultCp = TableController.CornerPermutationMoveTable[resultCp, (int)randomMoves[moveIndex]];
resultEo = TableController.EdgeOrientationMoveTable[resultEo, (int)randomMoves[moveIndex]];
resultEquatorDistribution = TableController.EquatorDistributionMoveTable[resultEquatorDistribution, (int)randomMoves[moveIndex]];
cube.ApplyMove(randomMoves[moveIndex]);
}
int expectedCo = Coordinates.GetCornerOrientation(cube);
Assert.AreEqual(expectedCo, resultCo);
int expectedCp = Coordinates.GetCornerPermutation(cube);
Assert.AreEqual(expectedCp, resultCp);
int expectedEo = Coordinates.GetEdgeOrientation(cube);
Assert.AreEqual(expectedEo, resultEo);
int expectedEquatorDistribution = Coordinates.GetEquatorDistribution(cube);
Assert.AreEqual(expectedEquatorDistribution, resultEquatorDistribution);
}
}
public void TestAllPhase2()
{
Random random = new Random(7777777);
int length = 50;
int repetitions = 50;
TableController.InitializeUdEdgeOrderMoveTable();
TableController.InitializeEquatorOrderMoveTable();
double[] moveProbabilities =
{
0d, 1d, 0d, 1d, 1d, 1d, 0d, 1d, 0d,
0d, 1d, 0d, 1d, 1d, 1d, 0d, 1d, 0d
};
int expectedEquatorPermutation;
for (int repetition = 0; repetition < repetitions; repetition++)
{
Alg randomMoves = Alg.FromRandomMoves(length, random, moveProbabilities);
int resultUdEdgeOrder = 0;
int resultEquatorPermutation = 0;
CubieCube cube = CubieCube.CreateSolved();
for (int moveIndex = 0; moveIndex < length; moveIndex++)
{
resultUdEdgeOrder = TableController.UdEdgeOrderMoveTable[resultUdEdgeOrder, MoveTables.Phase1IndexToPhase2Index[(int)randomMoves[moveIndex]]];
resultEquatorPermutation = TableController.EquatorOrderMoveTable[resultEquatorPermutation, (int)randomMoves[moveIndex]];
cube.ApplyMove(randomMoves[moveIndex]);
expectedEquatorPermutation = Coordinates.GetEquatorOrder(cube);
Assert.AreEqual(expectedEquatorPermutation, resultEquatorPermutation);
}
int expectedUdEdgeOrder = Coordinates.GetUdEdgeOrder(cube);
Assert.AreEqual(expectedUdEdgeOrder, resultUdEdgeOrder);
expectedEquatorPermutation = Coordinates.GetEquatorOrder(cube);
Assert.AreEqual(expectedEquatorPermutation, resultEquatorPermutation);
}
}
public void MoveReplacementTest(Action <CubieCube, CubieCube> test)
{
Alg uReplacementAlg = Alg.FromString("R L' F2 B2 R L' D L R' B2 F2 L R'");
foreach (Move move in Enum.GetValues(typeof(Move)))
{
foreach (Rotation rotation in Enum.GetValues(typeof(Rotation)))
{
if (Face.U.Rotate(rotation) == move.Face())
{
CubieCube result = CubieCube.CreateSolved();
result.ApplyMove(move);
CubieCube expected = CubieCube.CreateSolved();
expected.ApplyAlg(uReplacementAlg.Rotate(rotation) * move.QuarterTurns());
test(expected, result);
}
}
}
}
public void MultiplyTest()
{
Random random = new Random(7777777);
int length = 50;
Alg alg = Alg.FromRandomMoves(length, random);
CubieCube expected = CubieCube.CreateSolved();
CubieCube result = CubieCube.CreateSolved();
foreach (Move move in alg)
{
expected.ApplyMove(move);
CubieCube moveCube = CubieCube.CreateSolved();
moveCube.ApplyMove(move);
result.Multiply(moveCube);
}
Assert.AreEqual(expected, result);
Assert.ThrowsException <ArgumentNullException>(()
=> CubieCube.CreateSolved().Multiply(null));
}
