Test case generation for Plain text, cipher text for grain$128$AEAD stream cipher python code is not working.......

import numpy as np

class Grain$128$AEAD:

def $\_\_$init$\_\_($self$,$ key, iv$)$:

self.lfsr $=$ np$.$zeros$(128,$ dtype$=$np$.$uint$8)$

self.nfsr $=$ np$.$zeros$(128,$ dtype$=$np$.$uint$8)$

key$\_$bits $=$ np$.$array$([$int$($b$)$ for b in format$($key$,\text{'}0128$b$\text{'})],$ dtype$=$np$.$uint$8)$

iv$\_$bits $=$ np$.$array$([$int$($b$)$ for b in format$($iv$,\text{'}096$b$\text{'})],$ dtype$=$np$.$uint$8)$

self.nfsr$[$:$128]=$ key$\_$bits

self.lfsr$[$:$96]=$ iv$\_$bits

self.lfsr$[96$:$]=1$ # Set remaining bits to $1$

self.initialize$()$

def f$($self$,$ s$)$:

return s$[0]^$ s$[7]^$ s$[38]^$ s$[70]^$ s$[81]^$ s$[96]$

def g$($self$,$ b$)$:

return $($b$[0]^$ b$[26]^$ b$[56]^$ b$[91]^$ b$[96]^($b$[3]$ & b$[67])^$

$($b$[11]$ & b$[13])^($b$[17]$ & b$[18])^($b$[27]$ & b$[59])^$

$($b$[40]$ & b$[48])^($b$[61]$ & b$[65])^($b$[68]$ & b$[84]))$

def h$($self$,$ b$)$:

return $($b$[93]^$ b$[2]^$ b$[15]^$ b$[36]^$ b$[45]^$ b$[64]^$ b$[73]^$

$($b$[89]$ & b$[12])^($b$[8]$ & b$[13])^($b$[20]$ & b$[95])^$

$($b$[42]$ & b$[102])^($b$[60]$ & b$[79])^($b$[94]$ & b$[111]))$

def initialize$($self$)$:

for $\_$ in range$(256)$:

f$\_$out $=$ self.f$($self$.$lfsr$)$

g$\_$out $=$ self.g$($self$.$nfsr$)$

h$\_$out $=$ self.h$($self$.$nfsr$)$

self.lfsr $=$ np$.$roll$($self$.$lfsr$,-1)$

self.nfsr $=$ np$.$roll$($self$.$nfsr$,-1)$

self.lfsr$[-1]=$ f$\_$out $^$ h$\_$out

self.nfsr$[-1]=$ g$\_$out $^$ h$\_$out

def get$\_$keystream$\_$byte$($self$)$:

keystream $=0$

for i in range$(8)$:

f$\_$out $=$ self.f$($self$.$lfsr$)$

g$\_$out $=$ self.g$($self$.$nfsr$)$

h$\_$out $=$ self.h$($self$.$nfsr$)$

self.lfsr $=$ np$.$roll$($self$.$lfsr$,-1)$

self.nfsr $=$ np$.$roll$($self$.$nfsr$,-1)$

self.lfsr$[-1]=$ f$\_$out

self.nfsr$[-1]=$ g$\_$out

keystream $|=($h$\_$out $<<$ i$)$

return keystream

def encrypt$($self$,$ plaintext$)$:

if isinstance$($plaintext$,$ str$)$:

plaintext $=$ plaintext.encode$()$

ciphertext $=$ bytearray$()$

for byte in plaintext:

keystream$\_$byte $=$ self.get$\_$keystream$\_$byte$()$

ciphertext.append$($byte $^$ keystream$\_$byte$)$

return bytes$($ciphertext$)$

def decrypt$($self$,$ ciphertext$)$:

return self.encrypt$($ciphertext$)$

def generate$\_$test$\_$vectors$()$:

key $=0$x$0123456789$ABCDEF$0123456789$ABCDEF

iv $=0$x$0123456789$ABCDEF$0123456789$

cipher $=$ Grain$128$AEAD$($key$,$ iv$)$

test$\_$vectors $=[]$

plaintexts $=[$

"Hello, World!",

"Cryptography",

"Secret Message",

"Confidential",

"Secure Data",

"Test Vector $6",$

"Private Info",

"Protected",

"Classified",

"Important",

"Data Stream",

"Encryption",

"Algorithm",

"Security",

"Privacy",

"Information",

"Sensitive",

"Top Secret",

"Restricted",

"Final Test"

$]$

for plaintext in plaintexts:

cipher $=$ Grain$128$AEAD$($key$,$ iv$)$

ciphertext $=$ cipher.encrypt$($plaintext$)$

test$\_$vectors.append$(\{$

'plaintext': plaintext,

'ciphertext': ciphertext.hex$(),$

'length': len$($plaintext$)$

$\})$

return test$\_$vectors

test$\_$vectors $=$ generate$\_$test$\_$vectors$()$

print$("$Grain$-128$AEAD Test Vectors:"$)$

print$("-"*80)$

print$($f$"\{\text{'}$Plaintext$\text{'}$:$<20\}|\{\text{'}$Ciphertext$\text{'}$:$<40\}|\{\text{'}$Length$\text{'}$:$<6\}")$

print$("-"*80)$

for vector in test$\_$vectors:

print$($f$"\{$vector$[\text{'}$plaintext$\text{'}][$:$20]$:$<20\}|\{$vector$[\text{'}$ciphertext$\text{'}][$:$40]$:$<40\}|\{$vector$[\text{'}$length$\text{'}]$:$<6\}")$