create test code for this: export class MoveType $\{$

readonly deltar: number;

readonly deltac: number;

constructor$($dr: number, dc: number$)\{$

this.deltar $=$ dr;

this.deltac $=$ dc;

$\}$

static parse$($s: string$)$: MoveType $\{$

if $(($s $===$ "down"$)||($s $===$ "Down"$))\{$ return Down; $\}$

if $(($s $==="$up$")||($s $==="$Up$"))\{$ return Up; $\}$

if $(($s $===$ "left"$)||($s $===$ "Left"$))\{$ return Left; $\}$

if $(($s $===$ "right"$)||($s $===$ "Right"$))\{$ return Right; $\}$

return NoMove;

$\}$

$\}$

export const Down $=$ new MoveType$(1,0,$ "down"$)$;

export const Up $=$ new MoveType$(-1,0,"$up$")$;

export const Left $=$ new MoveType$(0,-1,$ "left"$)$;

export const Right $=$ new MoveType$(0,1,$ "right"$)$;

export const NoMove $=$ new MoveType$(0,0,"*")$; $//$ no move is possible

export class Coordinate $\{$

readonly row: number;

readonly column: number;

constructor$($row: number, column: number$)\{$

this.row $=$ row;

this.column $=$ column;

$\}$

$\}$

export class Piece $\{$

readonly width: number;

readonly height: number;

readonly isWinner: boolean;

readonly label: string

row: number;

column: number;

constructor$($w: number, h: number, isWinner: boolean, label: string$)\{$

this.width $=$ w;

this.height $=$ h;

this.isWinner $=$ isWinner;

this.row $=0$;

this.column $=0$;

this.label $=$ label

$\}$

move$($direction: MoveType$)\{$

this.row $+=$ direction.deltar

this.column $+=$ direction.deltac

$\}$

place$($row: number, col: number$)\{$

this.row $=$ row;

this.column $=$ col;

$\}$

location$()$: Coordinate $\{$

return new Coordinate$($this$.$row, this.column$)$

$\}$

contains$($coord: Coordinate$)$: boolean $\{$

for $($let r $=$ this.row; r $<$ this.row $+$ this.height; r$++)\{$

for $($let c $=$ this.column; c $<$ this.column $+$ this.width; c$++)\{$

if $($r $===$ coord.row && c $===$ coord.column$)\{$

return true

$\}$

$\}$

$\}$

return false $//$ nope: safe!

$\}$

copy$()$: Piece $\{$

let p $=$ new Piece$($this$.$width, this.height, this.isWinner, this.label$)$;

p$.$place$($this$.$row, this.column$)$;

return p;

$\}$

$\}$

export class Puzzle $\{$

readonly numRows: number;

readonly numColumns: number;

readonly destination: Coordinate;

readonly finalMove: MoveType;

selected: Piece $|$ undefined

pieces: Array $|$ undefined;

constructor$($numRows: number, numColumns: number, destination: Coordinate, finalMove: MoveType$)\{$

this.numRows $=$ numRows;

this.numColumns $=$ numColumns;

this.destination $=$ destination;

this.finalMove $=$ finalMove;

this.selected $=$ undefined;

$\}$

initialize$($pieces: Array$)\{$

$//$ make sure to create NEW Piece objects

this.pieces $=$ pieces.map$($p $=>$ p$.$copy$())$;

$\}$

$/**$ Determines if any piece in the puzzle covers given coordinate. $*/$

isCovered$($coord: Coordinate$)$: boolean $\{$

if $($this$.$pieces$)\{$

let p: Piece $|$ undefined $=$ this.pieces.find$($piece $=>\{$

return piece.contains$($coord$)$

$\})$

return p $!==$ undefined

$\}$

return false $//$ nothing

$\}$

find$($label:string$)$ : Piece$|$undefined $\{$

if $($this$.$pieces$)\{$

return this.pieces.find$($piece $=>\{$

return piece.label $===$ label

$\})$

$\}$

return undefined

$\}$

$/**$ Return all available moves given current state $($and selected Piece$)*/$

availableMoves$()$: Array $\{$

let selected $=$ this.selected

if $($selected $===$ undefined$)\{$ return $[]\}$

let moves: Array $=[]$;

let coord $=$ selected.location$()$;

$//$ can move left?

let available $=$ false

if $($coord$.$column $>0)\{$

available $=$ true;

for $($let r $=0$; r $<$ selected.height; r$++)\{$

if $($this$.$isCovered$($new Coordinate$($coord$.$row $+$ r$,$ coord.column $-1)))\{$

available $=$ false

break

$\}$

$\}$

if $($available$)\{$

moves.push$($Left$)$

$\}$

$\}$

$//$ can move right?

if $($coord$.$column $+$ selected.width $<$ this.numColumns$)\{$

available $=$ true;

for $($let r $=0$; r $<$ selected.height; r$++)\{$

if $($this$.$isCovered$($new Coordinate$($coord$.$row $+$ r$,$ coord.column $+$ selected.width$)))\{$

available $=$ false;

break

$\}$

$\}$

if $($available$)\{$

moves.push$($Right$)$;

$\}$

$\}$

$//$ can move up$?$

if $($coord$.$row $>0)\{$

available $=$ true;

for $($let c $=0$; c $<$ selected.width; c$++)\{$

if $($this$.$isCovered$($new Coordinate$($coord$.$row $-1,$ coord.column $+$ c$)))\{$

available $=$ false;

break;

$\}$

$\}$