public void ShouldNotChangeStringWhenClassIsNotGeneric() { string originalClass = typeof(String).AssemblyQualifiedName; string translatedClass = NotationHelper.ParseClrNotationToGenericName(originalClass); Assert.AreEqual(originalClass, translatedClass); }
public void ShouldNotChangeEmptyToCLRNotation() { string genericClass = "SmartClientFactoryPackage.Tests.NormalClass"; string translatedClass = NotationHelper.ParseGenericNameToCLRNotation(genericClass); Assert.AreEqual(genericClass, translatedClass); Assert.IsTrue(translatedClass.StartsWith("SmartClientFactoryPackage.Tests.NormalClass")); }
public void MoveCodesParsed(string moveCode, int expectedFrom, int expectedTo, int promotionPiece) { var move = NotationHelper.ParseMoveCode(moveCode); Assert.AreEqual(expectedFrom, move.StartSquare); Assert.AreEqual(expectedTo, move.EndSquare); Assert.AreEqual(promotionPiece, move.PromotionPiece); }
public void ShouldChangeStringToNamedArgumentWhenClassIsGenericWith11GenericParameters() { string originalClass = typeof(GenericClass11 <, , , , , , , , , ,>).AssemblyQualifiedName; string translatedClass = NotationHelper.ParseClrNotationToGenericName(originalClass); Assert.AreNotEqual(originalClass, translatedClass); Assert.IsTrue(translatedClass.StartsWith("SmartClientFactoryPackage.Tests.GenericClass11<A,B,C,D,E,F,G,H,I,J,K>")); }
public void ShouldChangeNamedArgumentToCLRNotation() { string genericClass = "SmartClientFactoryPackage.Tests.GenericClass2<T,G>"; string translatedClass = NotationHelper.ParseGenericNameToCLRNotation(genericClass); Assert.AreNotEqual(genericClass, translatedClass); Assert.IsTrue(translatedClass.StartsWith("SmartClientFactoryPackage.Tests.GenericClass2`2")); }
public void ShouldChangeStringWhenClassIsGeneric() { string originalClass = typeof(GenericClass <string>).AssemblyQualifiedName; string translatedClass = NotationHelper.ParseClrNotationToGenericName(originalClass); Assert.AreNotEqual(originalClass, translatedClass); Assert.IsTrue(translatedClass.StartsWith("SmartClientFactoryPackage.Tests.GenericClass<String>")); }
public static object GetProxyFactory(Type proxyType, string language) { object newValue = null; if (proxyType != null) { ProxyTechnology proxyTech = GetProxyTechnology(proxyType); if (proxyTech == ProxyTechnology.Asmx) { newValue = WebServiceProxyFactoryName; } else if (proxyTech == ProxyTechnology.Wcf) { Type genericImplementation = proxyType.BaseType; while (genericImplementation != typeof(Object)) { if (genericImplementation.IsGenericType && typeof(ClientBase <>).IsAssignableFrom(genericImplementation.GetGenericTypeDefinition())) { string wrappedServiceTypeName = string.Empty; Type[] generigArguments = genericImplementation.GetGenericArguments(); if (generigArguments.Length == 1) { wrappedServiceTypeName = generigArguments[0].FullName; } string clrNotationFactoryTypeName = WCFProxyFactoryGenericName; string genericFactoryTypeName = NotationHelper.RemoveTrailingCLRChars(clrNotationFactoryTypeName); newValue = string.Format(GetSelectedLanguageGenericFormat(language), genericFactoryTypeName, wrappedServiceTypeName); break; } genericImplementation = genericImplementation.BaseType; } } if (newValue == null) { newValue = ObjectProxyFactoryName; } } return(newValue); }
public void squareStringParsedTosquareId(string squareString, int expectedsquareId) { Assert.AreEqual(expectedsquareId, NotationHelper.ParseSquare(squareString)); }
public void PieceConvertedToTheChar(int piece, char expectedChar) { Assert.AreEqual(expectedChar, NotationHelper.GetPieceChar(piece)); }
public void ShouldRemoveCLRNotationCharacters() { string clrNotation = typeof(GenericClass <>).FullName; Assert.AreEqual("SmartClientFactoryPackage.Tests.GenericClass", NotationHelper.RemoveTrailingCLRChars(clrNotation)); }
public void MovesConvertedToStringCodes(Move move, string expectedMoveCode) { Assert.AreEqual(expectedMoveCode, NotationHelper.GetMoveCode(move)); }
public Position Read(string fenString) { try { PieceArray whitePieces = new PieceArray(0), blackPieces = new PieceArray(1); var chunks = fenString.Split(); bool isChess960 = !chunks[2].ToLower().Any(c => c == 'q' || c == 'k'); var boardChunks = chunks[0].Split(new[] { '/' }); for (int rank = 0; rank < Constants.BoardRanks; rank++) { var rankChunk = boardChunks[rank]; int file = 0; foreach (var item in rankChunk) { if (int.TryParse(item.ToString(), out var gap)) { file += gap; } else { int square = rank * Constants.BoardFiles + file; int piece = NotationHelper.GetPiece(item); if ((piece & Piece.White) != 0) { whitePieces.Add(piece & Piece.TypeMask, square); } else { blackPieces.Add(piece & Piece.TypeMask, square); } file++; } } } GameState initialGameState = new GameState(); if (chunks[2] != "-") { initialGameState[0] = NotationHelper.GetCastlingOptions(chunks[2], true, isChess960, whitePieces.Rooks, whitePieces.King); initialGameState[1] = NotationHelper.GetCastlingOptions(chunks[2], false, isChess960, blackPieces.Rooks, blackPieces.King); } if (chunks[3] != "-") { initialGameState.EnPassantSquare = NotationHelper.ParseSquare(chunks[3]); } int totalMoves = 1; if (chunks.Length > 4) { initialGameState.HalfMoveClock = int.Parse(chunks[4]); totalMoves = int.Parse(chunks[5]); } return(new Position(whitePieces, blackPieces, initialGameState) { WhiteToMove = chunks[1].ToLower() == "w", TotalMoves = totalMoves, IsChess960 = isChess960 }); } catch (Exception e) { throw new FormatException($"Wrong fen string: {fenString}", e); } }
public void InvalidsquareConvertedToStringThrows(int square) { Assert.Throws <ArgumentException>(() => NotationHelper.GetSquareString(square)); }
public void squareConvertedToString(int square, string expectedsquareString) { Assert.AreEqual(expectedsquareString, NotationHelper.GetSquareString(square)); }
public void InvalidPieceCharConvertedToIntThrows(char pieceChar) { Assert.Throws <ArgumentException>(() => NotationHelper.GetPiece(pieceChar)); }
public void PieceCharConvertedToInt(char pieceChar, int expectedPieceCode) { Assert.AreEqual(expectedPieceCode, NotationHelper.GetPiece(pieceChar)); }
public void InvalidPieceConvertedToTheCharThrows(int piece) { Assert.Throws <ArgumentException>(() => NotationHelper.GetPieceChar(piece)); }
public string Write(Position position, bool shortForm = false) { var res = new StringBuilder(); for (int rank = 0; rank < Constants.BoardRanks; rank++) { int gap = 0; for (int file = 0; file < Constants.BoardFiles; file++) { var piece = position[rank * Constants.BoardFiles + file]; if (piece != Piece.None) { if (gap > 0) { res.Append(gap); gap = 0; } char pieceChar = NotationHelper.GetPieceChar(piece); res.Append(pieceChar); } else { gap++; } } res.Append(gap > 0 ? gap.ToString() : string.Empty); if (rank < 7) { res.Append('/'); } } res.Append($" {(position.WhiteToMove ? 'w' : 'b')}"); if (position.CurrentState[0] != Castling.None || position.CurrentState[1] != Castling.None) { res.Append(' '); res.Append(NotationHelper.GetCastlingOptionsString(position.CurrentState[0], position.IsChess960, position.Pieces[0].Rooks, position.Pieces[0].King).ToUpper()); res.Append(NotationHelper.GetCastlingOptionsString(position.CurrentState[1], position.IsChess960, position.Pieces[1].Rooks, position.Pieces[1].King)); } else { res.Append(" -"); } if (position.CurrentState.EnPassantSquare > 0) { res.Append($" {NotationHelper.GetSquareString(position.CurrentState.EnPassantSquare)}"); } else { res.Append(" -"); } if (!shortForm) { res.Append($" {position.CurrentState.HalfMoveClock}"); res.Append($" {position.TotalMoves}"); } return(res.ToString()); }
public void InvalidsquareStringParsedTosquareIdThrows(string squareString) { Assert.Throws <ArgumentException>(() => NotationHelper.ParseSquare(squareString)); }
public override string ToString() { return(NotationHelper.GetMoveCode(this)); }
public void InvalidMoveCodesParseThrows(string moveCode) { Assert.Throws <ArgumentException>(() => NotationHelper.ParseMoveCode(moveCode)); }