# Note: Changing any part of the pre$-$implemented methods $($besides adding #

# default parameters$)$ will cause the Gradescope tests to fail. #

from static$\_$array import StaticArray

class QueueException$($Exception$)$:

$"""$

Custom exception to be used by Queue class.

DO NOT CHANGE THIS METHOD IN ANY WAY

$"""$

pass

class Queue:

def $\_\_$init$\_\_($self$)->$ None:

$"""$

Initialize new queue based on Static Array.

DO NOT CHANGE THIS METHOD IN ANY WAY

$"""$

self.$\_$sa $=$ StaticArray$(4)$

self.$\_$front $=0$

self.$\_$back $=-1$

self.$\_$current$\_$size $=0$

def $\_\_$str$\_\_($self$)->$ str:

$"""$

Override string method to provide more readable output.

DO NOT CHANGE THIS METHOD IN ANY WAY

$"""$

size $=$ self.$\_$current$\_$size

out $=$ "QUEUE: $"+$ str$($size$)+"$ element$($s$).["$

front$\_$index $=$ self.$\_$front

for $\_$ in range$($size $-1)$:

out $+=$ str$($self$.\_$sa$[$front$\_$index$])+\text{'},\text{'}$

front$\_$index $=$ self.$\_$increment$($front$\_$index$)$

if size $>0$:

out $+=$ str$($self$.\_$sa$[$front$\_$index$])$

return out $+\text{'}]\text{'}$

def is$\_$empty$($self$)->$ bool:

$"""$

Return True if the queue is empty, False otherwise.

DO NOT CHANGE THIS METHOD IN ANY WAY

$"""$

return self.$\_$current$\_$size $==0$

def size$($self$)->$ int:

$"""$

Return number of elements currently in the queue.

DO NOT CHANGE THIS METHOD IN ANY WAY

$"""$

return self.$\_$current$\_$size

def print$\_$underlying$\_$sa$($self$)->$ None:

$"""$

Print underlying StaticArray. Used for testing purposes.

DO NOT CHANGE THIS METHOD IN ANY WAY

$"""$

print$($self$.\_$sa$)$

def $\_$increment$($self$,$ index: int$)->$ int:

$"""$

Move index to next position.

DO NOT CHANGE THIS METHOD IN ANY WAY

$"""$

# employ wraparound if needed

index $+=1$

if index $==$ self.$\_$sa$.$length$()$:

index $=0$

return index

# $----------------------------------------------------------------------$ #

def enqueue$($self$,$ value: object$)->$ None:

$"""$

TODO: Write this implementation

$"""$

pass

def dequeue$($self$)->$ object:

$"""$

TODO: Write this implementation

$"""$

pass

def front$($self$)->$ object:

$"""$

TODO: Write this implementation

$"""$

pass

# The method below is optional, but recommended, to implement. #

# You may alter it in any way you see fit. #

def $\_$double$\_$queue$($self$)->$ None:

$"""$

TODO: Write this implementation

$"""$

pass

# $-------------------$ BASIC TESTING $-----------------------------------------$

if $\_\_$name$\_\_=="\_\_$main$\_\_"$:

print$("$

# Basic functionality tests #$")$

print$("$

# enqueue$()")$

q $=$ Queue$()$

print$($q$)$

for value in $[1,2,3,4,5]$:

q$.$enqueue$($value$)$

print$($q$)$

print$("$

# dequeue$()")$

q $=$ Queue$()$

for value in $[1,2,3,4,5]$:

q$.$enqueue$($value$)$

print$($q$)$

for $\_$ in range$($q$.$size$()+1)$:

try:

print$($q$.$dequeue$())$

except Exception as e:

print$("$No elements in queue", type$($e$))$

for value in $[6,7,8,111,222,3333,4444]$:

q$.$enqueue$($value$)$

print$($q$)$

q$.$print$\_$underlying$\_$sa$()$

print$("$

# front$()")$

q $=$ Queue$()$

print$($q$)$

for value in $[\text{'}$A$\text{'},\text{'}$B$\text{'},\text{'}$C$\text{'},\text{'}$D$\text{'}]$:

try:

print$($q$.$front$())$

except Exception as e:

print$("$No elements in queue", type$($e$))$

q$.$enqueue$($value$)$

print$($q$)$

print$("$

# Circular buffer tests: #

$")$

def action$\_$and$\_$print$($

header: str$,$ action: callable, values: $[],$ queue: Queue$)->$ None:

$"""$

Print header, perform action,

then print queue and its underlying storage.

$"""$

print$($header$)$

if values:

for value in values:

action$($value$)$

else:

action$()$

print$($queue$)$

queue.print$\_$underlying$\_$sa$()$

print$()$

q $=$ Queue$()$

# action$\_$and$\_$print$("$# Enqueue: $2,4,6,8",$ q$.$enqueue, $[2,4,6,8],$ q$)$

# Calling the action$\_$and$\_$print$()$ function declared two lines above,

# would be equivalent to following lines of code:

print$("$# Enqueue: $2,4,6,8")$

test$\_$case $=[2,4,6,8]$

for value in test$\_$case:

q$.$enqueue$($value$)$

print$($q$)$

q$.$print$\_$underlying$\_$sa$()$

print$()$

action$\_$and$\_$print$("$# Dequeue a value", q$.$dequeue, $[],$ q$)$

action$\_$and$\_$print$("$# Enqueue: $10",$ q$.$enqueue, $[10],$ q$)$

action$\_$and$\_$print$("$# Enqueue: $12",$ q$.$enqueue, $[12],$ q$)$

print$("$# Dequeue until empty"$)$

while not q$.$is$\_$empty$()$:

q$.$dequeue$()$

print$($q$)$

q$.$print$\_$underlying$\_$sa$()$

print$()$

action$\_$and$\_$print$("$# Enqueue: $14,16,18",$ q$.$enqueue, $[14,16,18],$ q$)$

action$\_$and$\_$print$("$# Enqueue: $20",$ q$.$enqueue, $[20],$ q$)$

action$\_$and$\_$print$("$# Enqueue: $22,24,26,28",$ q$.$enqueue,

$[22,24,26,28],$ q$)$

action$\_$and$\_$print$("$# Enqueue: $30",$ q$.$enqueue, $[30],$ q$)$